text: // Copyright (C) 2020 T. Zachary Laine
  //
  // Distributed under the Boost Software License, Version 1.0. (See
  // accompanying file LICENSE_1_0.txt or copy at
  // http://www.boost.org/LICENSE_1_0.txt)
  
  // Warning! This file is autogenerated.
  #include <boost/text/normalize_string.hpp>
  #include <boost/text/transcode_view.hpp>
  #include <boost/text/string_utility.hpp>
  
  #include <gtest/gtest.h>
  
  #include <algorithm>
  
  
  
  TEST(normalization, nfkc_063_000)
  {
      // D3C8;D3C8;1111 1167 11BB;D3C8;1111 1167 11BB; 
      // (폈; 폈; 폈; 폈; 폈; ) HANGUL SYLLABLE PYEOSS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3C8 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3C8 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1167, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3C8 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1167, 0x11BB }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_001)
  {
      // D3C9;D3C9;1111 1167 11BC;D3C9;1111 1167 11BC; 
      // (평; 평; 평; 평; 평; ) HANGUL SYLLABLE PYEONG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3C9 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3C9 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1167, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3C9 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1167, 0x11BC }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_002)
  {
      // D3CA;D3CA;1111 1167 11BD;D3CA;1111 1167 11BD; 
      // (폊; 폊; 폊; 폊; 폊; ) HANGUL SYLLABLE PYEOJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3CA }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3CA }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1167, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3CA }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1167, 0x11BD }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_003)
  {
      // D3CB;D3CB;1111 1167 11BE;D3CB;1111 1167 11BE; 
      // (폋; 폋; 폋; 폋; 폋; ) HANGUL SYLLABLE PYEOC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3CB }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3CB }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1167, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3CB }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1167, 0x11BE }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_004)
  {
      // D3CC;D3CC;1111 1167 11BF;D3CC;1111 1167 11BF; 
      // (폌; 폌; 폌; 폌; 폌; ) HANGUL SYLLABLE PYEOK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3CC }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3CC }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1167, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3CC }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1167, 0x11BF }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_005)
  {
      // D3CD;D3CD;1111 1167 11C0;D3CD;1111 1167 11C0; 
      // (폍; 폍; 폍; 폍; 폍; ) HANGUL SYLLABLE PYEOT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3CD }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3CD }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1167, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3CD }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1167, 0x11C0 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_006)
  {
      // D3CE;D3CE;1111 1167 11C1;D3CE;1111 1167 11C1; 
      // (폎; 폎; 폎; 폎; 폎; ) HANGUL SYLLABLE PYEOP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3CE }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3CE }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1167, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3CE }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1167, 0x11C1 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_007)
  {
      // D3CF;D3CF;1111 1167 11C2;D3CF;1111 1167 11C2; 
      // (폏; 폏; 폏; 폏; 폏; ) HANGUL SYLLABLE PYEOH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3CF }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3CF }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1167, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3CF }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1167, 0x11C2 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_008)
  {
      // D3D0;D3D0;1111 1168;D3D0;1111 1168; 
      // (폐; 폐; 폐; 폐; 폐; ) HANGUL SYLLABLE PYE
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3D0 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3D0 }};
          std::array<uint32_t, 2> const c3 = {{ 0x1111, 0x1168 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3D0 }};
          std::array<uint32_t, 2> const c5 = {{ 0x1111, 0x1168 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_009)
  {
      // D3D1;D3D1;1111 1168 11A8;D3D1;1111 1168 11A8; 
      // (폑; 폑; 폑; 폑; 폑; ) HANGUL SYLLABLE PYEG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3D1 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3D1 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3D1 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11A8 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_010)
  {
      // D3D2;D3D2;1111 1168 11A9;D3D2;1111 1168 11A9; 
      // (폒; 폒; 폒; 폒; 폒; ) HANGUL SYLLABLE PYEGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3D2 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3D2 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3D2 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11A9 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_011)
  {
      // D3D3;D3D3;1111 1168 11AA;D3D3;1111 1168 11AA; 
      // (폓; 폓; 폓; 폓; 폓; ) HANGUL SYLLABLE PYEGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3D3 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3D3 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3D3 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11AA }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_012)
  {
      // D3D4;D3D4;1111 1168 11AB;D3D4;1111 1168 11AB; 
      // (폔; 폔; 폔; 폔; 폔; ) HANGUL SYLLABLE PYEN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3D4 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3D4 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3D4 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11AB }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_013)
  {
      // D3D5;D3D5;1111 1168 11AC;D3D5;1111 1168 11AC; 
      // (폕; 폕; 폕; 폕; 폕; ) HANGUL SYLLABLE PYENJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3D5 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3D5 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3D5 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11AC }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_014)
  {
      // D3D6;D3D6;1111 1168 11AD;D3D6;1111 1168 11AD; 
      // (폖; 폖; 폖; 폖; 폖; ) HANGUL SYLLABLE PYENH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3D6 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3D6 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3D6 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11AD }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_015)
  {
      // D3D7;D3D7;1111 1168 11AE;D3D7;1111 1168 11AE; 
      // (폗; 폗; 폗; 폗; 폗; ) HANGUL SYLLABLE PYED
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3D7 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3D7 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3D7 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11AE }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_016)
  {
      // D3D8;D3D8;1111 1168 11AF;D3D8;1111 1168 11AF; 
      // (폘; 폘; 폘; 폘; 폘; ) HANGUL SYLLABLE PYEL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3D8 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3D8 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3D8 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11AF }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_017)
  {
      // D3D9;D3D9;1111 1168 11B0;D3D9;1111 1168 11B0; 
      // (폙; 폙; 폙; 폙; 폙; ) HANGUL SYLLABLE PYELG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3D9 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3D9 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3D9 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11B0 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_018)
  {
      // D3DA;D3DA;1111 1168 11B1;D3DA;1111 1168 11B1; 
      // (폚; 폚; 폚; 폚; 폚; ) HANGUL SYLLABLE PYELM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3DA }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3DA }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3DA }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11B1 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_019)
  {
      // D3DB;D3DB;1111 1168 11B2;D3DB;1111 1168 11B2; 
      // (폛; 폛; 폛; 폛; 폛; ) HANGUL SYLLABLE PYELB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3DB }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3DB }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3DB }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11B2 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_020)
  {
      // D3DC;D3DC;1111 1168 11B3;D3DC;1111 1168 11B3; 
      // (폜; 폜; 폜; 폜; 폜; ) HANGUL SYLLABLE PYELS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3DC }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3DC }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3DC }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11B3 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_021)
  {
      // D3DD;D3DD;1111 1168 11B4;D3DD;1111 1168 11B4; 
      // (폝; 폝; 폝; 폝; 폝; ) HANGUL SYLLABLE PYELT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3DD }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3DD }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3DD }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11B4 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_022)
  {
      // D3DE;D3DE;1111 1168 11B5;D3DE;1111 1168 11B5; 
      // (폞; 폞; 폞; 폞; 폞; ) HANGUL SYLLABLE PYELP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3DE }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3DE }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3DE }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11B5 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_023)
  {
      // D3DF;D3DF;1111 1168 11B6;D3DF;1111 1168 11B6; 
      // (폟; 폟; 폟; 폟; 폟; ) HANGUL SYLLABLE PYELH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3DF }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3DF }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3DF }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11B6 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_024)
  {
      // D3E0;D3E0;1111 1168 11B7;D3E0;1111 1168 11B7; 
      // (폠; 폠; 폠; 폠; 폠; ) HANGUL SYLLABLE PYEM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3E0 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3E0 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3E0 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11B7 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_025)
  {
      // D3E1;D3E1;1111 1168 11B8;D3E1;1111 1168 11B8; 
      // (폡; 폡; 폡; 폡; 폡; ) HANGUL SYLLABLE PYEB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3E1 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3E1 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3E1 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11B8 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_026)
  {
      // D3E2;D3E2;1111 1168 11B9;D3E2;1111 1168 11B9; 
      // (폢; 폢; 폢; 폢; 폢; ) HANGUL SYLLABLE PYEBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3E2 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3E2 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3E2 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11B9 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_027)
  {
      // D3E3;D3E3;1111 1168 11BA;D3E3;1111 1168 11BA; 
      // (폣; 폣; 폣; 폣; 폣; ) HANGUL SYLLABLE PYES
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3E3 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3E3 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3E3 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11BA }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_028)
  {
      // D3E4;D3E4;1111 1168 11BB;D3E4;1111 1168 11BB; 
      // (폤; 폤; 폤; 폤; 폤; ) HANGUL SYLLABLE PYESS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3E4 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3E4 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3E4 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11BB }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_029)
  {
      // D3E5;D3E5;1111 1168 11BC;D3E5;1111 1168 11BC; 
      // (폥; 폥; 폥; 폥; 폥; ) HANGUL SYLLABLE PYENG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3E5 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3E5 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3E5 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11BC }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_030)
  {
      // D3E6;D3E6;1111 1168 11BD;D3E6;1111 1168 11BD; 
      // (폦; 폦; 폦; 폦; 폦; ) HANGUL SYLLABLE PYEJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3E6 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3E6 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3E6 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11BD }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_031)
  {
      // D3E7;D3E7;1111 1168 11BE;D3E7;1111 1168 11BE; 
      // (폧; 폧; 폧; 폧; 폧; ) HANGUL SYLLABLE PYEC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3E7 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3E7 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3E7 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11BE }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_032)
  {
      // D3E8;D3E8;1111 1168 11BF;D3E8;1111 1168 11BF; 
      // (폨; 폨; 폨; 폨; 폨; ) HANGUL SYLLABLE PYEK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3E8 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3E8 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3E8 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11BF }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_033)
  {
      // D3E9;D3E9;1111 1168 11C0;D3E9;1111 1168 11C0; 
      // (폩; 폩; 폩; 폩; 폩; ) HANGUL SYLLABLE PYET
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3E9 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3E9 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3E9 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11C0 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_034)
  {
      // D3EA;D3EA;1111 1168 11C1;D3EA;1111 1168 11C1; 
      // (폪; 폪; 폪; 폪; 폪; ) HANGUL SYLLABLE PYEP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3EA }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3EA }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3EA }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11C1 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_035)
  {
      // D3EB;D3EB;1111 1168 11C2;D3EB;1111 1168 11C2; 
      // (폫; 폫; 폫; 폫; 폫; ) HANGUL SYLLABLE PYEH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3EB }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3EB }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1168, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3EB }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1168, 0x11C2 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_036)
  {
      // D3EC;D3EC;1111 1169;D3EC;1111 1169; 
      // (포; 포; 포; 포; 포; ) HANGUL SYLLABLE PO
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3EC }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3EC }};
          std::array<uint32_t, 2> const c3 = {{ 0x1111, 0x1169 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3EC }};
          std::array<uint32_t, 2> const c5 = {{ 0x1111, 0x1169 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_037)
  {
      // D3ED;D3ED;1111 1169 11A8;D3ED;1111 1169 11A8; 
      // (폭; 폭; 폭; 폭; 폭; ) HANGUL SYLLABLE POG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3ED }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3ED }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3ED }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11A8 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_038)
  {
      // D3EE;D3EE;1111 1169 11A9;D3EE;1111 1169 11A9; 
      // (폮; 폮; 폮; 폮; 폮; ) HANGUL SYLLABLE POGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3EE }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3EE }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3EE }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11A9 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_039)
  {
      // D3EF;D3EF;1111 1169 11AA;D3EF;1111 1169 11AA; 
      // (폯; 폯; 폯; 폯; 폯; ) HANGUL SYLLABLE POGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3EF }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3EF }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3EF }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11AA }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_040)
  {
      // D3F0;D3F0;1111 1169 11AB;D3F0;1111 1169 11AB; 
      // (폰; 폰; 폰; 폰; 폰; ) HANGUL SYLLABLE PON
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3F0 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3F0 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3F0 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11AB }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_041)
  {
      // D3F1;D3F1;1111 1169 11AC;D3F1;1111 1169 11AC; 
      // (폱; 폱; 폱; 폱; 폱; ) HANGUL SYLLABLE PONJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3F1 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3F1 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3F1 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11AC }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_042)
  {
      // D3F2;D3F2;1111 1169 11AD;D3F2;1111 1169 11AD; 
      // (폲; 폲; 폲; 폲; 폲; ) HANGUL SYLLABLE PONH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3F2 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3F2 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3F2 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11AD }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_043)
  {
      // D3F3;D3F3;1111 1169 11AE;D3F3;1111 1169 11AE; 
      // (폳; 폳; 폳; 폳; 폳; ) HANGUL SYLLABLE POD
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3F3 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3F3 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3F3 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11AE }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_044)
  {
      // D3F4;D3F4;1111 1169 11AF;D3F4;1111 1169 11AF; 
      // (폴; 폴; 폴; 폴; 폴; ) HANGUL SYLLABLE POL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3F4 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3F4 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3F4 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11AF }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_045)
  {
      // D3F5;D3F5;1111 1169 11B0;D3F5;1111 1169 11B0; 
      // (폵; 폵; 폵; 폵; 폵; ) HANGUL SYLLABLE POLG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3F5 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3F5 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3F5 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11B0 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_046)
  {
      // D3F6;D3F6;1111 1169 11B1;D3F6;1111 1169 11B1; 
      // (폶; 폶; 폶; 폶; 폶; ) HANGUL SYLLABLE POLM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3F6 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3F6 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3F6 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11B1 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_047)
  {
      // D3F7;D3F7;1111 1169 11B2;D3F7;1111 1169 11B2; 
      // (폷; 폷; 폷; 폷; 폷; ) HANGUL SYLLABLE POLB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3F7 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3F7 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3F7 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11B2 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_048)
  {
      // D3F8;D3F8;1111 1169 11B3;D3F8;1111 1169 11B3; 
      // (폸; 폸; 폸; 폸; 폸; ) HANGUL SYLLABLE POLS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3F8 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3F8 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3F8 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11B3 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_049)
  {
      // D3F9;D3F9;1111 1169 11B4;D3F9;1111 1169 11B4; 
      // (폹; 폹; 폹; 폹; 폹; ) HANGUL SYLLABLE POLT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3F9 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3F9 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3F9 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11B4 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_050)
  {
      // D3FA;D3FA;1111 1169 11B5;D3FA;1111 1169 11B5; 
      // (폺; 폺; 폺; 폺; 폺; ) HANGUL SYLLABLE POLP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3FA }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3FA }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3FA }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11B5 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_051)
  {
      // D3FB;D3FB;1111 1169 11B6;D3FB;1111 1169 11B6; 
      // (폻; 폻; 폻; 폻; 폻; ) HANGUL SYLLABLE POLH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3FB }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3FB }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3FB }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11B6 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_052)
  {
      // D3FC;D3FC;1111 1169 11B7;D3FC;1111 1169 11B7; 
      // (폼; 폼; 폼; 폼; 폼; ) HANGUL SYLLABLE POM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3FC }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3FC }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3FC }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11B7 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_053)
  {
      // D3FD;D3FD;1111 1169 11B8;D3FD;1111 1169 11B8; 
      // (폽; 폽; 폽; 폽; 폽; ) HANGUL SYLLABLE POB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3FD }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3FD }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3FD }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11B8 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_054)
  {
      // D3FE;D3FE;1111 1169 11B9;D3FE;1111 1169 11B9; 
      // (폾; 폾; 폾; 폾; 폾; ) HANGUL SYLLABLE POBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3FE }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3FE }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3FE }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11B9 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_055)
  {
      // D3FF;D3FF;1111 1169 11BA;D3FF;1111 1169 11BA; 
      // (폿; 폿; 폿; 폿; 폿; ) HANGUL SYLLABLE POS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD3FF }};
          std::array<uint32_t, 1> const c2 = {{ 0xD3FF }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD3FF }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11BA }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_056)
  {
      // D400;D400;1111 1169 11BB;D400;1111 1169 11BB; 
      // (퐀; 퐀; 퐀; 퐀; 퐀; ) HANGUL SYLLABLE POSS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD400 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD400 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD400 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11BB }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_057)
  {
      // D401;D401;1111 1169 11BC;D401;1111 1169 11BC; 
      // (퐁; 퐁; 퐁; 퐁; 퐁; ) HANGUL SYLLABLE PONG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD401 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD401 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD401 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11BC }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_058)
  {
      // D402;D402;1111 1169 11BD;D402;1111 1169 11BD; 
      // (퐂; 퐂; 퐂; 퐂; 퐂; ) HANGUL SYLLABLE POJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD402 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD402 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD402 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11BD }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_059)
  {
      // D403;D403;1111 1169 11BE;D403;1111 1169 11BE; 
      // (퐃; 퐃; 퐃; 퐃; 퐃; ) HANGUL SYLLABLE POC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD403 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD403 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD403 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11BE }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_060)
  {
      // D404;D404;1111 1169 11BF;D404;1111 1169 11BF; 
      // (퐄; 퐄; 퐄; 퐄; 퐄; ) HANGUL SYLLABLE POK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD404 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD404 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD404 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11BF }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_061)
  {
      // D405;D405;1111 1169 11C0;D405;1111 1169 11C0; 
      // (퐅; 퐅; 퐅; 퐅; 퐅; ) HANGUL SYLLABLE POT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD405 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD405 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD405 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11C0 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_062)
  {
      // D406;D406;1111 1169 11C1;D406;1111 1169 11C1; 
      // (퐆; 퐆; 퐆; 퐆; 퐆; ) HANGUL SYLLABLE POP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD406 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD406 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD406 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11C1 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_063)
  {
      // D407;D407;1111 1169 11C2;D407;1111 1169 11C2; 
      // (퐇; 퐇; 퐇; 퐇; 퐇; ) HANGUL SYLLABLE POH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD407 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD407 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x1169, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD407 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x1169, 0x11C2 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_064)
  {
      // D408;D408;1111 116A;D408;1111 116A; 
      // (퐈; 퐈; 퐈; 퐈; 퐈; ) HANGUL SYLLABLE PWA
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD408 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD408 }};
          std::array<uint32_t, 2> const c3 = {{ 0x1111, 0x116A }};
          std::array<uint32_t, 1> const c4 = {{ 0xD408 }};
          std::array<uint32_t, 2> const c5 = {{ 0x1111, 0x116A }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_065)
  {
      // D409;D409;1111 116A 11A8;D409;1111 116A 11A8; 
      // (퐉; 퐉; 퐉; 퐉; 퐉; ) HANGUL SYLLABLE PWAG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD409 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD409 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD409 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11A8 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_066)
  {
      // D40A;D40A;1111 116A 11A9;D40A;1111 116A 11A9; 
      // (퐊; 퐊; 퐊; 퐊; 퐊; ) HANGUL SYLLABLE PWAGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD40A }};
          std::array<uint32_t, 1> const c2 = {{ 0xD40A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD40A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11A9 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_067)
  {
      // D40B;D40B;1111 116A 11AA;D40B;1111 116A 11AA; 
      // (퐋; 퐋; 퐋; 퐋; 퐋; ) HANGUL SYLLABLE PWAGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD40B }};
          std::array<uint32_t, 1> const c2 = {{ 0xD40B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD40B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11AA }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_068)
  {
      // D40C;D40C;1111 116A 11AB;D40C;1111 116A 11AB; 
      // (퐌; 퐌; 퐌; 퐌; 퐌; ) HANGUL SYLLABLE PWAN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD40C }};
          std::array<uint32_t, 1> const c2 = {{ 0xD40C }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD40C }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11AB }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_069)
  {
      // D40D;D40D;1111 116A 11AC;D40D;1111 116A 11AC; 
      // (퐍; 퐍; 퐍; 퐍; 퐍; ) HANGUL SYLLABLE PWANJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD40D }};
          std::array<uint32_t, 1> const c2 = {{ 0xD40D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD40D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11AC }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_070)
  {
      // D40E;D40E;1111 116A 11AD;D40E;1111 116A 11AD; 
      // (퐎; 퐎; 퐎; 퐎; 퐎; ) HANGUL SYLLABLE PWANH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD40E }};
          std::array<uint32_t, 1> const c2 = {{ 0xD40E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD40E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11AD }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_071)
  {
      // D40F;D40F;1111 116A 11AE;D40F;1111 116A 11AE; 
      // (퐏; 퐏; 퐏; 퐏; 퐏; ) HANGUL SYLLABLE PWAD
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD40F }};
          std::array<uint32_t, 1> const c2 = {{ 0xD40F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD40F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11AE }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_072)
  {
      // D410;D410;1111 116A 11AF;D410;1111 116A 11AF; 
      // (퐐; 퐐; 퐐; 퐐; 퐐; ) HANGUL SYLLABLE PWAL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD410 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD410 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD410 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11AF }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_073)
  {
      // D411;D411;1111 116A 11B0;D411;1111 116A 11B0; 
      // (퐑; 퐑; 퐑; 퐑; 퐑; ) HANGUL SYLLABLE PWALG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD411 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD411 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD411 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11B0 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_074)
  {
      // D412;D412;1111 116A 11B1;D412;1111 116A 11B1; 
      // (퐒; 퐒; 퐒; 퐒; 퐒; ) HANGUL SYLLABLE PWALM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD412 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD412 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD412 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11B1 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_075)
  {
      // D413;D413;1111 116A 11B2;D413;1111 116A 11B2; 
      // (퐓; 퐓; 퐓; 퐓; 퐓; ) HANGUL SYLLABLE PWALB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD413 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD413 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD413 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11B2 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_076)
  {
      // D414;D414;1111 116A 11B3;D414;1111 116A 11B3; 
      // (퐔; 퐔; 퐔; 퐔; 퐔; ) HANGUL SYLLABLE PWALS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD414 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD414 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD414 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11B3 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_077)
  {
      // D415;D415;1111 116A 11B4;D415;1111 116A 11B4; 
      // (퐕; 퐕; 퐕; 퐕; 퐕; ) HANGUL SYLLABLE PWALT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD415 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD415 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD415 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11B4 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_078)
  {
      // D416;D416;1111 116A 11B5;D416;1111 116A 11B5; 
      // (퐖; 퐖; 퐖; 퐖; 퐖; ) HANGUL SYLLABLE PWALP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD416 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD416 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD416 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11B5 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_079)
  {
      // D417;D417;1111 116A 11B6;D417;1111 116A 11B6; 
      // (퐗; 퐗; 퐗; 퐗; 퐗; ) HANGUL SYLLABLE PWALH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD417 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD417 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD417 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11B6 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_080)
  {
      // D418;D418;1111 116A 11B7;D418;1111 116A 11B7; 
      // (퐘; 퐘; 퐘; 퐘; 퐘; ) HANGUL SYLLABLE PWAM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD418 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD418 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD418 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11B7 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_081)
  {
      // D419;D419;1111 116A 11B8;D419;1111 116A 11B8; 
      // (퐙; 퐙; 퐙; 퐙; 퐙; ) HANGUL SYLLABLE PWAB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD419 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD419 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD419 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11B8 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_082)
  {
      // D41A;D41A;1111 116A 11B9;D41A;1111 116A 11B9; 
      // (퐚; 퐚; 퐚; 퐚; 퐚; ) HANGUL SYLLABLE PWABS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD41A }};
          std::array<uint32_t, 1> const c2 = {{ 0xD41A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD41A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11B9 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_083)
  {
      // D41B;D41B;1111 116A 11BA;D41B;1111 116A 11BA; 
      // (퐛; 퐛; 퐛; 퐛; 퐛; ) HANGUL SYLLABLE PWAS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD41B }};
          std::array<uint32_t, 1> const c2 = {{ 0xD41B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD41B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11BA }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_084)
  {
      // D41C;D41C;1111 116A 11BB;D41C;1111 116A 11BB; 
      // (퐜; 퐜; 퐜; 퐜; 퐜; ) HANGUL SYLLABLE PWASS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD41C }};
          std::array<uint32_t, 1> const c2 = {{ 0xD41C }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD41C }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11BB }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_085)
  {
      // D41D;D41D;1111 116A 11BC;D41D;1111 116A 11BC; 
      // (퐝; 퐝; 퐝; 퐝; 퐝; ) HANGUL SYLLABLE PWANG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD41D }};
          std::array<uint32_t, 1> const c2 = {{ 0xD41D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD41D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11BC }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_086)
  {
      // D41E;D41E;1111 116A 11BD;D41E;1111 116A 11BD; 
      // (퐞; 퐞; 퐞; 퐞; 퐞; ) HANGUL SYLLABLE PWAJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD41E }};
          std::array<uint32_t, 1> const c2 = {{ 0xD41E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD41E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11BD }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_087)
  {
      // D41F;D41F;1111 116A 11BE;D41F;1111 116A 11BE; 
      // (퐟; 퐟; 퐟; 퐟; 퐟; ) HANGUL SYLLABLE PWAC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD41F }};
          std::array<uint32_t, 1> const c2 = {{ 0xD41F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD41F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11BE }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_088)
  {
      // D420;D420;1111 116A 11BF;D420;1111 116A 11BF; 
      // (퐠; 퐠; 퐠; 퐠; 퐠; ) HANGUL SYLLABLE PWAK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD420 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD420 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD420 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11BF }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_089)
  {
      // D421;D421;1111 116A 11C0;D421;1111 116A 11C0; 
      // (퐡; 퐡; 퐡; 퐡; 퐡; ) HANGUL SYLLABLE PWAT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD421 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD421 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD421 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11C0 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_090)
  {
      // D422;D422;1111 116A 11C1;D422;1111 116A 11C1; 
      // (퐢; 퐢; 퐢; 퐢; 퐢; ) HANGUL SYLLABLE PWAP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD422 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD422 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD422 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11C1 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_091)
  {
      // D423;D423;1111 116A 11C2;D423;1111 116A 11C2; 
      // (퐣; 퐣; 퐣; 퐣; 퐣; ) HANGUL SYLLABLE PWAH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD423 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD423 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116A, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD423 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116A, 0x11C2 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_092)
  {
      // D424;D424;1111 116B;D424;1111 116B; 
      // (퐤; 퐤; 퐤; 퐤; 퐤; ) HANGUL SYLLABLE PWAE
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD424 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD424 }};
          std::array<uint32_t, 2> const c3 = {{ 0x1111, 0x116B }};
          std::array<uint32_t, 1> const c4 = {{ 0xD424 }};
          std::array<uint32_t, 2> const c5 = {{ 0x1111, 0x116B }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_093)
  {
      // D425;D425;1111 116B 11A8;D425;1111 116B 11A8; 
      // (퐥; 퐥; 퐥; 퐥; 퐥; ) HANGUL SYLLABLE PWAEG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD425 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD425 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD425 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11A8 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_094)
  {
      // D426;D426;1111 116B 11A9;D426;1111 116B 11A9; 
      // (퐦; 퐦; 퐦; 퐦; 퐦; ) HANGUL SYLLABLE PWAEGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD426 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD426 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD426 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11A9 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_095)
  {
      // D427;D427;1111 116B 11AA;D427;1111 116B 11AA; 
      // (퐧; 퐧; 퐧; 퐧; 퐧; ) HANGUL SYLLABLE PWAEGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD427 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD427 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD427 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11AA }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_096)
  {
      // D428;D428;1111 116B 11AB;D428;1111 116B 11AB; 
      // (퐨; 퐨; 퐨; 퐨; 퐨; ) HANGUL SYLLABLE PWAEN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD428 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD428 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD428 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11AB }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_097)
  {
      // D429;D429;1111 116B 11AC;D429;1111 116B 11AC; 
      // (퐩; 퐩; 퐩; 퐩; 퐩; ) HANGUL SYLLABLE PWAENJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD429 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD429 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD429 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11AC }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_098)
  {
      // D42A;D42A;1111 116B 11AD;D42A;1111 116B 11AD; 
      // (퐪; 퐪; 퐪; 퐪; 퐪; ) HANGUL SYLLABLE PWAENH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD42A }};
          std::array<uint32_t, 1> const c2 = {{ 0xD42A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD42A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11AD }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_099)
  {
      // D42B;D42B;1111 116B 11AE;D42B;1111 116B 11AE; 
      // (퐫; 퐫; 퐫; 퐫; 퐫; ) HANGUL SYLLABLE PWAED
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD42B }};
          std::array<uint32_t, 1> const c2 = {{ 0xD42B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD42B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11AE }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_100)
  {
      // D42C;D42C;1111 116B 11AF;D42C;1111 116B 11AF; 
      // (퐬; 퐬; 퐬; 퐬; 퐬; ) HANGUL SYLLABLE PWAEL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD42C }};
          std::array<uint32_t, 1> const c2 = {{ 0xD42C }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD42C }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11AF }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_101)
  {
      // D42D;D42D;1111 116B 11B0;D42D;1111 116B 11B0; 
      // (퐭; 퐭; 퐭; 퐭; 퐭; ) HANGUL SYLLABLE PWAELG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD42D }};
          std::array<uint32_t, 1> const c2 = {{ 0xD42D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD42D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11B0 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_102)
  {
      // D42E;D42E;1111 116B 11B1;D42E;1111 116B 11B1; 
      // (퐮; 퐮; 퐮; 퐮; 퐮; ) HANGUL SYLLABLE PWAELM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD42E }};
          std::array<uint32_t, 1> const c2 = {{ 0xD42E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD42E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11B1 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_103)
  {
      // D42F;D42F;1111 116B 11B2;D42F;1111 116B 11B2; 
      // (퐯; 퐯; 퐯; 퐯; 퐯; ) HANGUL SYLLABLE PWAELB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD42F }};
          std::array<uint32_t, 1> const c2 = {{ 0xD42F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD42F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11B2 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_104)
  {
      // D430;D430;1111 116B 11B3;D430;1111 116B 11B3; 
      // (퐰; 퐰; 퐰; 퐰; 퐰; ) HANGUL SYLLABLE PWAELS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD430 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD430 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD430 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11B3 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_105)
  {
      // D431;D431;1111 116B 11B4;D431;1111 116B 11B4; 
      // (퐱; 퐱; 퐱; 퐱; 퐱; ) HANGUL SYLLABLE PWAELT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD431 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD431 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD431 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11B4 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_106)
  {
      // D432;D432;1111 116B 11B5;D432;1111 116B 11B5; 
      // (퐲; 퐲; 퐲; 퐲; 퐲; ) HANGUL SYLLABLE PWAELP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD432 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD432 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD432 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11B5 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_107)
  {
      // D433;D433;1111 116B 11B6;D433;1111 116B 11B6; 
      // (퐳; 퐳; 퐳; 퐳; 퐳; ) HANGUL SYLLABLE PWAELH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD433 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD433 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD433 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11B6 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_108)
  {
      // D434;D434;1111 116B 11B7;D434;1111 116B 11B7; 
      // (퐴; 퐴; 퐴; 퐴; 퐴; ) HANGUL SYLLABLE PWAEM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD434 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD434 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD434 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11B7 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_109)
  {
      // D435;D435;1111 116B 11B8;D435;1111 116B 11B8; 
      // (퐵; 퐵; 퐵; 퐵; 퐵; ) HANGUL SYLLABLE PWAEB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD435 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD435 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD435 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11B8 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_110)
  {
      // D436;D436;1111 116B 11B9;D436;1111 116B 11B9; 
      // (퐶; 퐶; 퐶; 퐶; 퐶; ) HANGUL SYLLABLE PWAEBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD436 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD436 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD436 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11B9 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_111)
  {
      // D437;D437;1111 116B 11BA;D437;1111 116B 11BA; 
      // (퐷; 퐷; 퐷; 퐷; 퐷; ) HANGUL SYLLABLE PWAES
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD437 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD437 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD437 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11BA }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_112)
  {
      // D438;D438;1111 116B 11BB;D438;1111 116B 11BB; 
      // (퐸; 퐸; 퐸; 퐸; 퐸; ) HANGUL SYLLABLE PWAESS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD438 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD438 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD438 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11BB }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_113)
  {
      // D439;D439;1111 116B 11BC;D439;1111 116B 11BC; 
      // (퐹; 퐹; 퐹; 퐹; 퐹; ) HANGUL SYLLABLE PWAENG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD439 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD439 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD439 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11BC }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_114)
  {
      // D43A;D43A;1111 116B 11BD;D43A;1111 116B 11BD; 
      // (퐺; 퐺; 퐺; 퐺; 퐺; ) HANGUL SYLLABLE PWAEJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD43A }};
          std::array<uint32_t, 1> const c2 = {{ 0xD43A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD43A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11BD }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_115)
  {
      // D43B;D43B;1111 116B 11BE;D43B;1111 116B 11BE; 
      // (퐻; 퐻; 퐻; 퐻; 퐻; ) HANGUL SYLLABLE PWAEC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD43B }};
          std::array<uint32_t, 1> const c2 = {{ 0xD43B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD43B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11BE }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_116)
  {
      // D43C;D43C;1111 116B 11BF;D43C;1111 116B 11BF; 
      // (퐼; 퐼; 퐼; 퐼; 퐼; ) HANGUL SYLLABLE PWAEK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD43C }};
          std::array<uint32_t, 1> const c2 = {{ 0xD43C }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD43C }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11BF }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_117)
  {
      // D43D;D43D;1111 116B 11C0;D43D;1111 116B 11C0; 
      // (퐽; 퐽; 퐽; 퐽; 퐽; ) HANGUL SYLLABLE PWAET
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD43D }};
          std::array<uint32_t, 1> const c2 = {{ 0xD43D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD43D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11C0 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_118)
  {
      // D43E;D43E;1111 116B 11C1;D43E;1111 116B 11C1; 
      // (퐾; 퐾; 퐾; 퐾; 퐾; ) HANGUL SYLLABLE PWAEP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD43E }};
          std::array<uint32_t, 1> const c2 = {{ 0xD43E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD43E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11C1 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_119)
  {
      // D43F;D43F;1111 116B 11C2;D43F;1111 116B 11C2; 
      // (퐿; 퐿; 퐿; 퐿; 퐿; ) HANGUL SYLLABLE PWAEH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD43F }};
          std::array<uint32_t, 1> const c2 = {{ 0xD43F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116B, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD43F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116B, 0x11C2 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_120)
  {
      // D440;D440;1111 116C;D440;1111 116C; 
      // (푀; 푀; 푀; 푀; 푀; ) HANGUL SYLLABLE POE
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD440 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD440 }};
          std::array<uint32_t, 2> const c3 = {{ 0x1111, 0x116C }};
          std::array<uint32_t, 1> const c4 = {{ 0xD440 }};
          std::array<uint32_t, 2> const c5 = {{ 0x1111, 0x116C }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_121)
  {
      // D441;D441;1111 116C 11A8;D441;1111 116C 11A8; 
      // (푁; 푁; 푁; 푁; 푁; ) HANGUL SYLLABLE POEG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD441 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD441 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD441 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11A8 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_122)
  {
      // D442;D442;1111 116C 11A9;D442;1111 116C 11A9; 
      // (푂; 푂; 푂; 푂; 푂; ) HANGUL SYLLABLE POEGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD442 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD442 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD442 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11A9 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_123)
  {
      // D443;D443;1111 116C 11AA;D443;1111 116C 11AA; 
      // (푃; 푃; 푃; 푃; 푃; ) HANGUL SYLLABLE POEGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD443 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD443 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD443 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11AA }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_124)
  {
      // D444;D444;1111 116C 11AB;D444;1111 116C 11AB; 
      // (푄; 푄; 푄; 푄; 푄; ) HANGUL SYLLABLE POEN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD444 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD444 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD444 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11AB }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_125)
  {
      // D445;D445;1111 116C 11AC;D445;1111 116C 11AC; 
      // (푅; 푅; 푅; 푅; 푅; ) HANGUL SYLLABLE POENJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD445 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD445 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD445 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11AC }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_126)
  {
      // D446;D446;1111 116C 11AD;D446;1111 116C 11AD; 
      // (푆; 푆; 푆; 푆; 푆; ) HANGUL SYLLABLE POENH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD446 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD446 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD446 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11AD }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_127)
  {
      // D447;D447;1111 116C 11AE;D447;1111 116C 11AE; 
      // (푇; 푇; 푇; 푇; 푇; ) HANGUL SYLLABLE POED
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD447 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD447 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD447 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11AE }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_128)
  {
      // D448;D448;1111 116C 11AF;D448;1111 116C 11AF; 
      // (푈; 푈; 푈; 푈; 푈; ) HANGUL SYLLABLE POEL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD448 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD448 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD448 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11AF }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_129)
  {
      // D449;D449;1111 116C 11B0;D449;1111 116C 11B0; 
      // (푉; 푉; 푉; 푉; 푉; ) HANGUL SYLLABLE POELG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD449 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD449 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD449 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11B0 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_130)
  {
      // D44A;D44A;1111 116C 11B1;D44A;1111 116C 11B1; 
      // (푊; 푊; 푊; 푊; 푊; ) HANGUL SYLLABLE POELM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD44A }};
          std::array<uint32_t, 1> const c2 = {{ 0xD44A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD44A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11B1 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_131)
  {
      // D44B;D44B;1111 116C 11B2;D44B;1111 116C 11B2; 
      // (푋; 푋; 푋; 푋; 푋; ) HANGUL SYLLABLE POELB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD44B }};
          std::array<uint32_t, 1> const c2 = {{ 0xD44B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD44B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11B2 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_132)
  {
      // D44C;D44C;1111 116C 11B3;D44C;1111 116C 11B3; 
      // (푌; 푌; 푌; 푌; 푌; ) HANGUL SYLLABLE POELS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD44C }};
          std::array<uint32_t, 1> const c2 = {{ 0xD44C }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD44C }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11B3 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_133)
  {
      // D44D;D44D;1111 116C 11B4;D44D;1111 116C 11B4; 
      // (푍; 푍; 푍; 푍; 푍; ) HANGUL SYLLABLE POELT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD44D }};
          std::array<uint32_t, 1> const c2 = {{ 0xD44D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD44D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11B4 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_134)
  {
      // D44E;D44E;1111 116C 11B5;D44E;1111 116C 11B5; 
      // (푎; 푎; 푎; 푎; 푎; ) HANGUL SYLLABLE POELP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD44E }};
          std::array<uint32_t, 1> const c2 = {{ 0xD44E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD44E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11B5 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_135)
  {
      // D44F;D44F;1111 116C 11B6;D44F;1111 116C 11B6; 
      // (푏; 푏; 푏; 푏; 푏; ) HANGUL SYLLABLE POELH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD44F }};
          std::array<uint32_t, 1> const c2 = {{ 0xD44F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD44F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11B6 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_136)
  {
      // D450;D450;1111 116C 11B7;D450;1111 116C 11B7; 
      // (푐; 푐; 푐; 푐; 푐; ) HANGUL SYLLABLE POEM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD450 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD450 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD450 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11B7 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_137)
  {
      // D451;D451;1111 116C 11B8;D451;1111 116C 11B8; 
      // (푑; 푑; 푑; 푑; 푑; ) HANGUL SYLLABLE POEB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD451 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD451 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD451 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11B8 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_138)
  {
      // D452;D452;1111 116C 11B9;D452;1111 116C 11B9; 
      // (푒; 푒; 푒; 푒; 푒; ) HANGUL SYLLABLE POEBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD452 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD452 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD452 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11B9 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_139)
  {
      // D453;D453;1111 116C 11BA;D453;1111 116C 11BA; 
      // (푓; 푓; 푓; 푓; 푓; ) HANGUL SYLLABLE POES
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD453 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD453 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD453 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11BA }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_140)
  {
      // D454;D454;1111 116C 11BB;D454;1111 116C 11BB; 
      // (푔; 푔; 푔; 푔; 푔; ) HANGUL SYLLABLE POESS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD454 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD454 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD454 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11BB }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_141)
  {
      // D455;D455;1111 116C 11BC;D455;1111 116C 11BC; 
      // (푕; 푕; 푕; 푕; 푕; ) HANGUL SYLLABLE POENG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD455 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD455 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD455 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11BC }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_142)
  {
      // D456;D456;1111 116C 11BD;D456;1111 116C 11BD; 
      // (푖; 푖; 푖; 푖; 푖; ) HANGUL SYLLABLE POEJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD456 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD456 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD456 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11BD }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_143)
  {
      // D457;D457;1111 116C 11BE;D457;1111 116C 11BE; 
      // (푗; 푗; 푗; 푗; 푗; ) HANGUL SYLLABLE POEC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD457 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD457 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD457 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11BE }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_144)
  {
      // D458;D458;1111 116C 11BF;D458;1111 116C 11BF; 
      // (푘; 푘; 푘; 푘; 푘; ) HANGUL SYLLABLE POEK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD458 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD458 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD458 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11BF }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_145)
  {
      // D459;D459;1111 116C 11C0;D459;1111 116C 11C0; 
      // (푙; 푙; 푙; 푙; 푙; ) HANGUL SYLLABLE POET
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD459 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD459 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD459 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11C0 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_146)
  {
      // D45A;D45A;1111 116C 11C1;D45A;1111 116C 11C1; 
      // (푚; 푚; 푚; 푚; 푚; ) HANGUL SYLLABLE POEP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD45A }};
          std::array<uint32_t, 1> const c2 = {{ 0xD45A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD45A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11C1 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_147)
  {
      // D45B;D45B;1111 116C 11C2;D45B;1111 116C 11C2; 
      // (푛; 푛; 푛; 푛; 푛; ) HANGUL SYLLABLE POEH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD45B }};
          std::array<uint32_t, 1> const c2 = {{ 0xD45B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116C, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD45B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116C, 0x11C2 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_148)
  {
      // D45C;D45C;1111 116D;D45C;1111 116D; 
      // (표; 표; 표; 표; 표; ) HANGUL SYLLABLE PYO
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD45C }};
          std::array<uint32_t, 1> const c2 = {{ 0xD45C }};
          std::array<uint32_t, 2> const c3 = {{ 0x1111, 0x116D }};
          std::array<uint32_t, 1> const c4 = {{ 0xD45C }};
          std::array<uint32_t, 2> const c5 = {{ 0x1111, 0x116D }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_149)
  {
      // D45D;D45D;1111 116D 11A8;D45D;1111 116D 11A8; 
      // (푝; 푝; 푝; 푝; 푝; ) HANGUL SYLLABLE PYOG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD45D }};
          std::array<uint32_t, 1> const c2 = {{ 0xD45D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD45D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11A8 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_150)
  {
      // D45E;D45E;1111 116D 11A9;D45E;1111 116D 11A9; 
      // (푞; 푞; 푞; 푞; 푞; ) HANGUL SYLLABLE PYOGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD45E }};
          std::array<uint32_t, 1> const c2 = {{ 0xD45E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD45E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11A9 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_151)
  {
      // D45F;D45F;1111 116D 11AA;D45F;1111 116D 11AA; 
      // (푟; 푟; 푟; 푟; 푟; ) HANGUL SYLLABLE PYOGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD45F }};
          std::array<uint32_t, 1> const c2 = {{ 0xD45F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD45F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11AA }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_152)
  {
      // D460;D460;1111 116D 11AB;D460;1111 116D 11AB; 
      // (푠; 푠; 푠; 푠; 푠; ) HANGUL SYLLABLE PYON
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD460 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD460 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD460 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11AB }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_153)
  {
      // D461;D461;1111 116D 11AC;D461;1111 116D 11AC; 
      // (푡; 푡; 푡; 푡; 푡; ) HANGUL SYLLABLE PYONJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD461 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD461 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD461 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11AC }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_154)
  {
      // D462;D462;1111 116D 11AD;D462;1111 116D 11AD; 
      // (푢; 푢; 푢; 푢; 푢; ) HANGUL SYLLABLE PYONH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD462 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD462 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD462 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11AD }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_155)
  {
      // D463;D463;1111 116D 11AE;D463;1111 116D 11AE; 
      // (푣; 푣; 푣; 푣; 푣; ) HANGUL SYLLABLE PYOD
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD463 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD463 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD463 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11AE }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_156)
  {
      // D464;D464;1111 116D 11AF;D464;1111 116D 11AF; 
      // (푤; 푤; 푤; 푤; 푤; ) HANGUL SYLLABLE PYOL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD464 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD464 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD464 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11AF }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_157)
  {
      // D465;D465;1111 116D 11B0;D465;1111 116D 11B0; 
      // (푥; 푥; 푥; 푥; 푥; ) HANGUL SYLLABLE PYOLG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD465 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD465 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD465 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11B0 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_158)
  {
      // D466;D466;1111 116D 11B1;D466;1111 116D 11B1; 
      // (푦; 푦; 푦; 푦; 푦; ) HANGUL SYLLABLE PYOLM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD466 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD466 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD466 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11B1 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_159)
  {
      // D467;D467;1111 116D 11B2;D467;1111 116D 11B2; 
      // (푧; 푧; 푧; 푧; 푧; ) HANGUL SYLLABLE PYOLB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD467 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD467 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD467 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11B2 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_160)
  {
      // D468;D468;1111 116D 11B3;D468;1111 116D 11B3; 
      // (푨; 푨; 푨; 푨; 푨; ) HANGUL SYLLABLE PYOLS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD468 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD468 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD468 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11B3 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_161)
  {
      // D469;D469;1111 116D 11B4;D469;1111 116D 11B4; 
      // (푩; 푩; 푩; 푩; 푩; ) HANGUL SYLLABLE PYOLT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD469 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD469 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD469 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11B4 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_162)
  {
      // D46A;D46A;1111 116D 11B5;D46A;1111 116D 11B5; 
      // (푪; 푪; 푪; 푪; 푪; ) HANGUL SYLLABLE PYOLP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD46A }};
          std::array<uint32_t, 1> const c2 = {{ 0xD46A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD46A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11B5 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_163)
  {
      // D46B;D46B;1111 116D 11B6;D46B;1111 116D 11B6; 
      // (푫; 푫; 푫; 푫; 푫; ) HANGUL SYLLABLE PYOLH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD46B }};
          std::array<uint32_t, 1> const c2 = {{ 0xD46B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD46B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11B6 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_164)
  {
      // D46C;D46C;1111 116D 11B7;D46C;1111 116D 11B7; 
      // (푬; 푬; 푬; 푬; 푬; ) HANGUL SYLLABLE PYOM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD46C }};
          std::array<uint32_t, 1> const c2 = {{ 0xD46C }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD46C }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11B7 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_165)
  {
      // D46D;D46D;1111 116D 11B8;D46D;1111 116D 11B8; 
      // (푭; 푭; 푭; 푭; 푭; ) HANGUL SYLLABLE PYOB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD46D }};
          std::array<uint32_t, 1> const c2 = {{ 0xD46D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD46D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11B8 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_166)
  {
      // D46E;D46E;1111 116D 11B9;D46E;1111 116D 11B9; 
      // (푮; 푮; 푮; 푮; 푮; ) HANGUL SYLLABLE PYOBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD46E }};
          std::array<uint32_t, 1> const c2 = {{ 0xD46E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD46E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11B9 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_167)
  {
      // D46F;D46F;1111 116D 11BA;D46F;1111 116D 11BA; 
      // (푯; 푯; 푯; 푯; 푯; ) HANGUL SYLLABLE PYOS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD46F }};
          std::array<uint32_t, 1> const c2 = {{ 0xD46F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD46F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11BA }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_168)
  {
      // D470;D470;1111 116D 11BB;D470;1111 116D 11BB; 
      // (푰; 푰; 푰; 푰; 푰; ) HANGUL SYLLABLE PYOSS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD470 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD470 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD470 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11BB }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_169)
  {
      // D471;D471;1111 116D 11BC;D471;1111 116D 11BC; 
      // (푱; 푱; 푱; 푱; 푱; ) HANGUL SYLLABLE PYONG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD471 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD471 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD471 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11BC }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_170)
  {
      // D472;D472;1111 116D 11BD;D472;1111 116D 11BD; 
      // (푲; 푲; 푲; 푲; 푲; ) HANGUL SYLLABLE PYOJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD472 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD472 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD472 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11BD }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_171)
  {
      // D473;D473;1111 116D 11BE;D473;1111 116D 11BE; 
      // (푳; 푳; 푳; 푳; 푳; ) HANGUL SYLLABLE PYOC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD473 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD473 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD473 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11BE }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_172)
  {
      // D474;D474;1111 116D 11BF;D474;1111 116D 11BF; 
      // (푴; 푴; 푴; 푴; 푴; ) HANGUL SYLLABLE PYOK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD474 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD474 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD474 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11BF }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_173)
  {
      // D475;D475;1111 116D 11C0;D475;1111 116D 11C0; 
      // (푵; 푵; 푵; 푵; 푵; ) HANGUL SYLLABLE PYOT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD475 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD475 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD475 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11C0 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_174)
  {
      // D476;D476;1111 116D 11C1;D476;1111 116D 11C1; 
      // (푶; 푶; 푶; 푶; 푶; ) HANGUL SYLLABLE PYOP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD476 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD476 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD476 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11C1 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_175)
  {
      // D477;D477;1111 116D 11C2;D477;1111 116D 11C2; 
      // (푷; 푷; 푷; 푷; 푷; ) HANGUL SYLLABLE PYOH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD477 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD477 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116D, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD477 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116D, 0x11C2 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_176)
  {
      // D478;D478;1111 116E;D478;1111 116E; 
      // (푸; 푸; 푸; 푸; 푸; ) HANGUL SYLLABLE PU
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD478 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD478 }};
          std::array<uint32_t, 2> const c3 = {{ 0x1111, 0x116E }};
          std::array<uint32_t, 1> const c4 = {{ 0xD478 }};
          std::array<uint32_t, 2> const c5 = {{ 0x1111, 0x116E }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_177)
  {
      // D479;D479;1111 116E 11A8;D479;1111 116E 11A8; 
      // (푹; 푹; 푹; 푹; 푹; ) HANGUL SYLLABLE PUG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD479 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD479 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116E, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD479 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116E, 0x11A8 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_178)
  {
      // D47A;D47A;1111 116E 11A9;D47A;1111 116E 11A9; 
      // (푺; 푺; 푺; 푺; 푺; ) HANGUL SYLLABLE PUGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD47A }};
          std::array<uint32_t, 1> const c2 = {{ 0xD47A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116E, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD47A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116E, 0x11A9 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_179)
  {
      // D47B;D47B;1111 116E 11AA;D47B;1111 116E 11AA; 
      // (푻; 푻; 푻; 푻; 푻; ) HANGUL SYLLABLE PUGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD47B }};
          std::array<uint32_t, 1> const c2 = {{ 0xD47B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116E, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD47B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116E, 0x11AA }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_180)
  {
      // D47C;D47C;1111 116E 11AB;D47C;1111 116E 11AB; 
      // (푼; 푼; 푼; 푼; 푼; ) HANGUL SYLLABLE PUN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD47C }};
          std::array<uint32_t, 1> const c2 = {{ 0xD47C }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116E, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD47C }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116E, 0x11AB }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_181)
  {
      // D47D;D47D;1111 116E 11AC;D47D;1111 116E 11AC; 
      // (푽; 푽; 푽; 푽; 푽; ) HANGUL SYLLABLE PUNJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD47D }};
          std::array<uint32_t, 1> const c2 = {{ 0xD47D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116E, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD47D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116E, 0x11AC }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_182)
  {
      // D47E;D47E;1111 116E 11AD;D47E;1111 116E 11AD; 
      // (푾; 푾; 푾; 푾; 푾; ) HANGUL SYLLABLE PUNH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD47E }};
          std::array<uint32_t, 1> const c2 = {{ 0xD47E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116E, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD47E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116E, 0x11AD }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_183)
  {
      // D47F;D47F;1111 116E 11AE;D47F;1111 116E 11AE; 
      // (푿; 푿; 푿; 푿; 푿; ) HANGUL SYLLABLE PUD
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD47F }};
          std::array<uint32_t, 1> const c2 = {{ 0xD47F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116E, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD47F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116E, 0x11AE }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_184)
  {
      // D480;D480;1111 116E 11AF;D480;1111 116E 11AF; 
      // (풀; 풀; 풀; 풀; 풀; ) HANGUL SYLLABLE PUL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD480 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD480 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116E, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD480 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116E, 0x11AF }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_185)
  {
      // D481;D481;1111 116E 11B0;D481;1111 116E 11B0; 
      // (풁; 풁; 풁; 풁; 풁; ) HANGUL SYLLABLE PULG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD481 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD481 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116E, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD481 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116E, 0x11B0 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_186)
  {
      // D482;D482;1111 116E 11B1;D482;1111 116E 11B1; 
      // (풂; 풂; 풂; 풂; 풂; ) HANGUL SYLLABLE PULM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD482 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD482 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116E, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD482 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116E, 0x11B1 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_187)
  {
      // D483;D483;1111 116E 11B2;D483;1111 116E 11B2; 
      // (풃; 풃; 풃; 풃; 풃; ) HANGUL SYLLABLE PULB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD483 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD483 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116E, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD483 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116E, 0x11B2 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_188)
  {
      // D484;D484;1111 116E 11B3;D484;1111 116E 11B3; 
      // (풄; 풄; 풄; 풄; 풄; ) HANGUL SYLLABLE PULS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD484 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD484 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116E, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD484 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116E, 0x11B3 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_189)
  {
      // D485;D485;1111 116E 11B4;D485;1111 116E 11B4; 
      // (풅; 풅; 풅; 풅; 풅; ) HANGUL SYLLABLE PULT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD485 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD485 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116E, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD485 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116E, 0x11B4 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_190)
  {
      // D486;D486;1111 116E 11B5;D486;1111 116E 11B5; 
      // (풆; 풆; 풆; 풆; 풆; ) HANGUL SYLLABLE PULP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD486 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD486 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116E, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD486 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116E, 0x11B5 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_191)
  {
      // D487;D487;1111 116E 11B6;D487;1111 116E 11B6; 
      // (풇; 풇; 풇; 풇; 풇; ) HANGUL SYLLABLE PULH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD487 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD487 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116E, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD487 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116E, 0x11B6 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_192)
  {
      // D488;D488;1111 116E 11B7;D488;1111 116E 11B7; 
      // (품; 품; 품; 품; 품; ) HANGUL SYLLABLE PUM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD488 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD488 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116E, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD488 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116E, 0x11B7 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_193)
  {
      // D489;D489;1111 116E 11B8;D489;1111 116E 11B8; 
      // (풉; 풉; 풉; 풉; 풉; ) HANGUL SYLLABLE PUB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD489 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD489 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116E, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD489 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116E, 0x11B8 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_194)
  {
      // D48A;D48A;1111 116E 11B9;D48A;1111 116E 11B9; 
      // (풊; 풊; 풊; 풊; 풊; ) HANGUL SYLLABLE PUBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD48A }};
          std::array<uint32_t, 1> const c2 = {{ 0xD48A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116E, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD48A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116E, 0x11B9 }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_195)
  {
      // D48B;D48B;1111 116E 11BA;D48B;1111 116E 11BA; 
      // (풋; 풋; 풋; 풋; 풋; ) HANGUL SYLLABLE PUS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD48B }};
          std::array<uint32_t, 1> const c2 = {{ 0xD48B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116E, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD48B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116E, 0x11BA }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_196)
  {
      // D48C;D48C;1111 116E 11BB;D48C;1111 116E 11BB; 
      // (풌; 풌; 풌; 풌; 풌; ) HANGUL SYLLABLE PUSS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD48C }};
          std::array<uint32_t, 1> const c2 = {{ 0xD48C }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116E, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD48C }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116E, 0x11BB }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_197)
  {
      // D48D;D48D;1111 116E 11BC;D48D;1111 116E 11BC; 
      // (풍; 풍; 풍; 풍; 풍; ) HANGUL SYLLABLE PUNG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD48D }};
          std::array<uint32_t, 1> const c2 = {{ 0xD48D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116E, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD48D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116E, 0x11BC }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_198)
  {
      // D48E;D48E;1111 116E 11BD;D48E;1111 116E 11BD; 
      // (풎; 풎; 풎; 풎; 풎; ) HANGUL SYLLABLE PUJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD48E }};
          std::array<uint32_t, 1> const c2 = {{ 0xD48E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116E, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD48E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116E, 0x11BD }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_063_199)
  {
      // D48F;D48F;1111 116E 11BE;D48F;1111 116E 11BE; 
      // (풏; 풏; 풏; 풏; 풏; ) HANGUL SYLLABLE PUC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD48F }};
          std::array<uint32_t, 1> const c2 = {{ 0xD48F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1111, 0x116E, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD48F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1111, 0x116E, 0x11BE }};
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::c>(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kc>(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::d>(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized<boost::text::nf::kd>(c5.begin(), c5.end()));
  
  
  
          {
              std::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize<boost::text::nf::kc>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  