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, nfc_057_000)
  {
      // CF18;CF18;110F 1166 11BF;CF18;110F 1166 11BF; 
      // (켘; 켘; 켘; 켘; 켘; ) HANGUL SYLLABLE KEK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF18 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF18 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1166, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF18 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 0x1166, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_001)
  {
      // CF19;CF19;110F 1166 11C0;CF19;110F 1166 11C0; 
      // (켙; 켙; 켙; 켙; 켙; ) HANGUL SYLLABLE KET
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF19 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF19 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1166, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF19 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 0x1166, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_002)
  {
      // CF1A;CF1A;110F 1166 11C1;CF1A;110F 1166 11C1; 
      // (켚; 켚; 켚; 켚; 켚; ) HANGUL SYLLABLE KEP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF1A }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF1A }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1166, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF1A }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 0x1166, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_003)
  {
      // CF1B;CF1B;110F 1166 11C2;CF1B;110F 1166 11C2; 
      // (켛; 켛; 켛; 켛; 켛; ) HANGUL SYLLABLE KEH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF1B }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF1B }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1166, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF1B }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 0x1166, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_004)
  {
      // CF1C;CF1C;110F 1167;CF1C;110F 1167; 
      // (켜; 켜; 켜; 켜; 켜; ) HANGUL SYLLABLE KYEO
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF1C }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF1C }};
          std::array<uint32_t, 2> const c3 = {{ 0x110F, 0x1167 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF1C }};
          std::array<uint32_t, 2> const c5 = {{ 0x110F, 0x1167 }};
  
          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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_005)
  {
      // CF1D;CF1D;110F 1167 11A8;CF1D;110F 1167 11A8; 
      // (켝; 켝; 켝; 켝; 켝; ) HANGUL SYLLABLE KYEOG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF1D }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF1D }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF1D }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 0x1167, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_006)
  {
      // CF1E;CF1E;110F 1167 11A9;CF1E;110F 1167 11A9; 
      // (켞; 켞; 켞; 켞; 켞; ) HANGUL SYLLABLE KYEOGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF1E }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF1E }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF1E }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 0x1167, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_007)
  {
      // CF1F;CF1F;110F 1167 11AA;CF1F;110F 1167 11AA; 
      // (켟; 켟; 켟; 켟; 켟; ) HANGUL SYLLABLE KYEOGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF1F }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF1F }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF1F }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 0x1167, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_008)
  {
      // CF20;CF20;110F 1167 11AB;CF20;110F 1167 11AB; 
      // (켠; 켠; 켠; 켠; 켠; ) HANGUL SYLLABLE KYEON
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF20 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF20 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF20 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 0x1167, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_009)
  {
      // CF21;CF21;110F 1167 11AC;CF21;110F 1167 11AC; 
      // (켡; 켡; 켡; 켡; 켡; ) HANGUL SYLLABLE KYEONJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF21 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF21 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF21 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 0x1167, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_010)
  {
      // CF22;CF22;110F 1167 11AD;CF22;110F 1167 11AD; 
      // (켢; 켢; 켢; 켢; 켢; ) HANGUL SYLLABLE KYEONH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF22 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF22 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF22 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 0x1167, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_011)
  {
      // CF23;CF23;110F 1167 11AE;CF23;110F 1167 11AE; 
      // (켣; 켣; 켣; 켣; 켣; ) HANGUL SYLLABLE KYEOD
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF23 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF23 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF23 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 0x1167, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_012)
  {
      // CF24;CF24;110F 1167 11AF;CF24;110F 1167 11AF; 
      // (켤; 켤; 켤; 켤; 켤; ) HANGUL SYLLABLE KYEOL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF24 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF24 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF24 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 0x1167, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_013)
  {
      // CF25;CF25;110F 1167 11B0;CF25;110F 1167 11B0; 
      // (켥; 켥; 켥; 켥; 켥; ) HANGUL SYLLABLE KYEOLG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF25 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF25 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF25 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 0x1167, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_014)
  {
      // CF26;CF26;110F 1167 11B1;CF26;110F 1167 11B1; 
      // (켦; 켦; 켦; 켦; 켦; ) HANGUL SYLLABLE KYEOLM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF26 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF26 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF26 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 0x1167, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_015)
  {
      // CF27;CF27;110F 1167 11B2;CF27;110F 1167 11B2; 
      // (켧; 켧; 켧; 켧; 켧; ) HANGUL SYLLABLE KYEOLB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF27 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF27 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF27 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 0x1167, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_016)
  {
      // CF28;CF28;110F 1167 11B3;CF28;110F 1167 11B3; 
      // (켨; 켨; 켨; 켨; 켨; ) HANGUL SYLLABLE KYEOLS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF28 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF28 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF28 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 0x1167, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_017)
  {
      // CF29;CF29;110F 1167 11B4;CF29;110F 1167 11B4; 
      // (켩; 켩; 켩; 켩; 켩; ) HANGUL SYLLABLE KYEOLT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF29 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF29 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF29 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 0x1167, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_018)
  {
      // CF2A;CF2A;110F 1167 11B5;CF2A;110F 1167 11B5; 
      // (켪; 켪; 켪; 켪; 켪; ) HANGUL SYLLABLE KYEOLP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF2A }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF2A }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF2A }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 0x1167, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_019)
  {
      // CF2B;CF2B;110F 1167 11B6;CF2B;110F 1167 11B6; 
      // (켫; 켫; 켫; 켫; 켫; ) HANGUL SYLLABLE KYEOLH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF2B }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF2B }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF2B }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 0x1167, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_020)
  {
      // CF2C;CF2C;110F 1167 11B7;CF2C;110F 1167 11B7; 
      // (켬; 켬; 켬; 켬; 켬; ) HANGUL SYLLABLE KYEOM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF2C }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF2C }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF2C }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 0x1167, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_021)
  {
      // CF2D;CF2D;110F 1167 11B8;CF2D;110F 1167 11B8; 
      // (켭; 켭; 켭; 켭; 켭; ) HANGUL SYLLABLE KYEOB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF2D }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF2D }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF2D }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 0x1167, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_022)
  {
      // CF2E;CF2E;110F 1167 11B9;CF2E;110F 1167 11B9; 
      // (켮; 켮; 켮; 켮; 켮; ) HANGUL SYLLABLE KYEOBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF2E }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF2E }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF2E }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 0x1167, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_023)
  {
      // CF2F;CF2F;110F 1167 11BA;CF2F;110F 1167 11BA; 
      // (켯; 켯; 켯; 켯; 켯; ) HANGUL SYLLABLE KYEOS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF2F }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF2F }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF2F }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 0x1167, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_024)
  {
      // CF30;CF30;110F 1167 11BB;CF30;110F 1167 11BB; 
      // (켰; 켰; 켰; 켰; 켰; ) HANGUL SYLLABLE KYEOSS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF30 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF30 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF30 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_025)
  {
      // CF31;CF31;110F 1167 11BC;CF31;110F 1167 11BC; 
      // (켱; 켱; 켱; 켱; 켱; ) HANGUL SYLLABLE KYEONG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF31 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF31 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF31 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_026)
  {
      // CF32;CF32;110F 1167 11BD;CF32;110F 1167 11BD; 
      // (켲; 켲; 켲; 켲; 켲; ) HANGUL SYLLABLE KYEOJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF32 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF32 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF32 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_027)
  {
      // CF33;CF33;110F 1167 11BE;CF33;110F 1167 11BE; 
      // (켳; 켳; 켳; 켳; 켳; ) HANGUL SYLLABLE KYEOC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF33 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF33 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF33 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_028)
  {
      // CF34;CF34;110F 1167 11BF;CF34;110F 1167 11BF; 
      // (켴; 켴; 켴; 켴; 켴; ) HANGUL SYLLABLE KYEOK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF34 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF34 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF34 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_029)
  {
      // CF35;CF35;110F 1167 11C0;CF35;110F 1167 11C0; 
      // (켵; 켵; 켵; 켵; 켵; ) HANGUL SYLLABLE KYEOT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF35 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF35 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF35 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_030)
  {
      // CF36;CF36;110F 1167 11C1;CF36;110F 1167 11C1; 
      // (켶; 켶; 켶; 켶; 켶; ) HANGUL SYLLABLE KYEOP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF36 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF36 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF36 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_031)
  {
      // CF37;CF37;110F 1167 11C2;CF37;110F 1167 11C2; 
      // (켷; 켷; 켷; 켷; 켷; ) HANGUL SYLLABLE KYEOH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF37 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF37 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1167, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF37 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_032)
  {
      // CF38;CF38;110F 1168;CF38;110F 1168; 
      // (켸; 켸; 켸; 켸; 켸; ) HANGUL SYLLABLE KYE
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF38 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF38 }};
          std::array<uint32_t, 2> const c3 = {{ 0x110F, 0x1168 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF38 }};
          std::array<uint32_t, 2> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_033)
  {
      // CF39;CF39;110F 1168 11A8;CF39;110F 1168 11A8; 
      // (켹; 켹; 켹; 켹; 켹; ) HANGUL SYLLABLE KYEG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF39 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF39 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF39 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_034)
  {
      // CF3A;CF3A;110F 1168 11A9;CF3A;110F 1168 11A9; 
      // (켺; 켺; 켺; 켺; 켺; ) HANGUL SYLLABLE KYEGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF3A }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF3A }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF3A }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_035)
  {
      // CF3B;CF3B;110F 1168 11AA;CF3B;110F 1168 11AA; 
      // (켻; 켻; 켻; 켻; 켻; ) HANGUL SYLLABLE KYEGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF3B }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF3B }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF3B }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_036)
  {
      // CF3C;CF3C;110F 1168 11AB;CF3C;110F 1168 11AB; 
      // (켼; 켼; 켼; 켼; 켼; ) HANGUL SYLLABLE KYEN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF3C }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF3C }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF3C }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_037)
  {
      // CF3D;CF3D;110F 1168 11AC;CF3D;110F 1168 11AC; 
      // (켽; 켽; 켽; 켽; 켽; ) HANGUL SYLLABLE KYENJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF3D }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF3D }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF3D }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_038)
  {
      // CF3E;CF3E;110F 1168 11AD;CF3E;110F 1168 11AD; 
      // (켾; 켾; 켾; 켾; 켾; ) HANGUL SYLLABLE KYENH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF3E }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF3E }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF3E }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_039)
  {
      // CF3F;CF3F;110F 1168 11AE;CF3F;110F 1168 11AE; 
      // (켿; 켿; 켿; 켿; 켿; ) HANGUL SYLLABLE KYED
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF3F }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF3F }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF3F }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_040)
  {
      // CF40;CF40;110F 1168 11AF;CF40;110F 1168 11AF; 
      // (콀; 콀; 콀; 콀; 콀; ) HANGUL SYLLABLE KYEL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF40 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF40 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF40 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_041)
  {
      // CF41;CF41;110F 1168 11B0;CF41;110F 1168 11B0; 
      // (콁; 콁; 콁; 콁; 콁; ) HANGUL SYLLABLE KYELG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF41 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF41 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF41 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_042)
  {
      // CF42;CF42;110F 1168 11B1;CF42;110F 1168 11B1; 
      // (콂; 콂; 콂; 콂; 콂; ) HANGUL SYLLABLE KYELM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF42 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF42 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF42 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_043)
  {
      // CF43;CF43;110F 1168 11B2;CF43;110F 1168 11B2; 
      // (콃; 콃; 콃; 콃; 콃; ) HANGUL SYLLABLE KYELB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF43 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF43 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF43 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_044)
  {
      // CF44;CF44;110F 1168 11B3;CF44;110F 1168 11B3; 
      // (콄; 콄; 콄; 콄; 콄; ) HANGUL SYLLABLE KYELS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF44 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF44 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF44 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_045)
  {
      // CF45;CF45;110F 1168 11B4;CF45;110F 1168 11B4; 
      // (콅; 콅; 콅; 콅; 콅; ) HANGUL SYLLABLE KYELT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF45 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF45 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF45 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_046)
  {
      // CF46;CF46;110F 1168 11B5;CF46;110F 1168 11B5; 
      // (콆; 콆; 콆; 콆; 콆; ) HANGUL SYLLABLE KYELP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF46 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF46 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF46 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_047)
  {
      // CF47;CF47;110F 1168 11B6;CF47;110F 1168 11B6; 
      // (콇; 콇; 콇; 콇; 콇; ) HANGUL SYLLABLE KYELH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF47 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF47 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF47 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_048)
  {
      // CF48;CF48;110F 1168 11B7;CF48;110F 1168 11B7; 
      // (콈; 콈; 콈; 콈; 콈; ) HANGUL SYLLABLE KYEM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF48 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF48 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF48 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_049)
  {
      // CF49;CF49;110F 1168 11B8;CF49;110F 1168 11B8; 
      // (콉; 콉; 콉; 콉; 콉; ) HANGUL SYLLABLE KYEB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF49 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF49 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF49 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_050)
  {
      // CF4A;CF4A;110F 1168 11B9;CF4A;110F 1168 11B9; 
      // (콊; 콊; 콊; 콊; 콊; ) HANGUL SYLLABLE KYEBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF4A }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF4A }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF4A }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_051)
  {
      // CF4B;CF4B;110F 1168 11BA;CF4B;110F 1168 11BA; 
      // (콋; 콋; 콋; 콋; 콋; ) HANGUL SYLLABLE KYES
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF4B }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF4B }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF4B }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_052)
  {
      // CF4C;CF4C;110F 1168 11BB;CF4C;110F 1168 11BB; 
      // (콌; 콌; 콌; 콌; 콌; ) HANGUL SYLLABLE KYESS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF4C }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF4C }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF4C }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_053)
  {
      // CF4D;CF4D;110F 1168 11BC;CF4D;110F 1168 11BC; 
      // (콍; 콍; 콍; 콍; 콍; ) HANGUL SYLLABLE KYENG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF4D }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF4D }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF4D }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_054)
  {
      // CF4E;CF4E;110F 1168 11BD;CF4E;110F 1168 11BD; 
      // (콎; 콎; 콎; 콎; 콎; ) HANGUL SYLLABLE KYEJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF4E }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF4E }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF4E }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_055)
  {
      // CF4F;CF4F;110F 1168 11BE;CF4F;110F 1168 11BE; 
      // (콏; 콏; 콏; 콏; 콏; ) HANGUL SYLLABLE KYEC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF4F }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF4F }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF4F }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_056)
  {
      // CF50;CF50;110F 1168 11BF;CF50;110F 1168 11BF; 
      // (콐; 콐; 콐; 콐; 콐; ) HANGUL SYLLABLE KYEK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF50 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF50 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF50 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_057)
  {
      // CF51;CF51;110F 1168 11C0;CF51;110F 1168 11C0; 
      // (콑; 콑; 콑; 콑; 콑; ) HANGUL SYLLABLE KYET
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF51 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF51 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF51 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_058)
  {
      // CF52;CF52;110F 1168 11C1;CF52;110F 1168 11C1; 
      // (콒; 콒; 콒; 콒; 콒; ) HANGUL SYLLABLE KYEP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF52 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF52 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF52 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_059)
  {
      // CF53;CF53;110F 1168 11C2;CF53;110F 1168 11C2; 
      // (콓; 콓; 콓; 콓; 콓; ) HANGUL SYLLABLE KYEH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF53 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF53 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1168, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF53 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_060)
  {
      // CF54;CF54;110F 1169;CF54;110F 1169; 
      // (코; 코; 코; 코; 코; ) HANGUL SYLLABLE KO
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF54 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF54 }};
          std::array<uint32_t, 2> const c3 = {{ 0x110F, 0x1169 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF54 }};
          std::array<uint32_t, 2> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_061)
  {
      // CF55;CF55;110F 1169 11A8;CF55;110F 1169 11A8; 
      // (콕; 콕; 콕; 콕; 콕; ) HANGUL SYLLABLE KOG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF55 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF55 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF55 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_062)
  {
      // CF56;CF56;110F 1169 11A9;CF56;110F 1169 11A9; 
      // (콖; 콖; 콖; 콖; 콖; ) HANGUL SYLLABLE KOGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF56 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF56 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF56 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_063)
  {
      // CF57;CF57;110F 1169 11AA;CF57;110F 1169 11AA; 
      // (콗; 콗; 콗; 콗; 콗; ) HANGUL SYLLABLE KOGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF57 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF57 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF57 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_064)
  {
      // CF58;CF58;110F 1169 11AB;CF58;110F 1169 11AB; 
      // (콘; 콘; 콘; 콘; 콘; ) HANGUL SYLLABLE KON
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF58 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF58 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF58 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_065)
  {
      // CF59;CF59;110F 1169 11AC;CF59;110F 1169 11AC; 
      // (콙; 콙; 콙; 콙; 콙; ) HANGUL SYLLABLE KONJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF59 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF59 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF59 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_066)
  {
      // CF5A;CF5A;110F 1169 11AD;CF5A;110F 1169 11AD; 
      // (콚; 콚; 콚; 콚; 콚; ) HANGUL SYLLABLE KONH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF5A }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF5A }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF5A }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_067)
  {
      // CF5B;CF5B;110F 1169 11AE;CF5B;110F 1169 11AE; 
      // (콛; 콛; 콛; 콛; 콛; ) HANGUL SYLLABLE KOD
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF5B }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF5B }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF5B }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_068)
  {
      // CF5C;CF5C;110F 1169 11AF;CF5C;110F 1169 11AF; 
      // (콜; 콜; 콜; 콜; 콜; ) HANGUL SYLLABLE KOL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF5C }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF5C }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF5C }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_069)
  {
      // CF5D;CF5D;110F 1169 11B0;CF5D;110F 1169 11B0; 
      // (콝; 콝; 콝; 콝; 콝; ) HANGUL SYLLABLE KOLG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF5D }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF5D }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF5D }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_070)
  {
      // CF5E;CF5E;110F 1169 11B1;CF5E;110F 1169 11B1; 
      // (콞; 콞; 콞; 콞; 콞; ) HANGUL SYLLABLE KOLM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF5E }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF5E }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF5E }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_071)
  {
      // CF5F;CF5F;110F 1169 11B2;CF5F;110F 1169 11B2; 
      // (콟; 콟; 콟; 콟; 콟; ) HANGUL SYLLABLE KOLB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF5F }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF5F }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF5F }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_072)
  {
      // CF60;CF60;110F 1169 11B3;CF60;110F 1169 11B3; 
      // (콠; 콠; 콠; 콠; 콠; ) HANGUL SYLLABLE KOLS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF60 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF60 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF60 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_073)
  {
      // CF61;CF61;110F 1169 11B4;CF61;110F 1169 11B4; 
      // (콡; 콡; 콡; 콡; 콡; ) HANGUL SYLLABLE KOLT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF61 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF61 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF61 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_074)
  {
      // CF62;CF62;110F 1169 11B5;CF62;110F 1169 11B5; 
      // (콢; 콢; 콢; 콢; 콢; ) HANGUL SYLLABLE KOLP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF62 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF62 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF62 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_075)
  {
      // CF63;CF63;110F 1169 11B6;CF63;110F 1169 11B6; 
      // (콣; 콣; 콣; 콣; 콣; ) HANGUL SYLLABLE KOLH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF63 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF63 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF63 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_076)
  {
      // CF64;CF64;110F 1169 11B7;CF64;110F 1169 11B7; 
      // (콤; 콤; 콤; 콤; 콤; ) HANGUL SYLLABLE KOM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF64 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF64 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF64 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_077)
  {
      // CF65;CF65;110F 1169 11B8;CF65;110F 1169 11B8; 
      // (콥; 콥; 콥; 콥; 콥; ) HANGUL SYLLABLE KOB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF65 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF65 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF65 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_078)
  {
      // CF66;CF66;110F 1169 11B9;CF66;110F 1169 11B9; 
      // (콦; 콦; 콦; 콦; 콦; ) HANGUL SYLLABLE KOBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF66 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF66 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF66 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_079)
  {
      // CF67;CF67;110F 1169 11BA;CF67;110F 1169 11BA; 
      // (콧; 콧; 콧; 콧; 콧; ) HANGUL SYLLABLE KOS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF67 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF67 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF67 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_080)
  {
      // CF68;CF68;110F 1169 11BB;CF68;110F 1169 11BB; 
      // (콨; 콨; 콨; 콨; 콨; ) HANGUL SYLLABLE KOSS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF68 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF68 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF68 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_081)
  {
      // CF69;CF69;110F 1169 11BC;CF69;110F 1169 11BC; 
      // (콩; 콩; 콩; 콩; 콩; ) HANGUL SYLLABLE KONG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF69 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF69 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF69 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_082)
  {
      // CF6A;CF6A;110F 1169 11BD;CF6A;110F 1169 11BD; 
      // (콪; 콪; 콪; 콪; 콪; ) HANGUL SYLLABLE KOJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF6A }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF6A }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF6A }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_083)
  {
      // CF6B;CF6B;110F 1169 11BE;CF6B;110F 1169 11BE; 
      // (콫; 콫; 콫; 콫; 콫; ) HANGUL SYLLABLE KOC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF6B }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF6B }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF6B }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_084)
  {
      // CF6C;CF6C;110F 1169 11BF;CF6C;110F 1169 11BF; 
      // (콬; 콬; 콬; 콬; 콬; ) HANGUL SYLLABLE KOK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF6C }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF6C }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF6C }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_085)
  {
      // CF6D;CF6D;110F 1169 11C0;CF6D;110F 1169 11C0; 
      // (콭; 콭; 콭; 콭; 콭; ) HANGUL SYLLABLE KOT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF6D }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF6D }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF6D }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_086)
  {
      // CF6E;CF6E;110F 1169 11C1;CF6E;110F 1169 11C1; 
      // (콮; 콮; 콮; 콮; 콮; ) HANGUL SYLLABLE KOP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF6E }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF6E }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF6E }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_087)
  {
      // CF6F;CF6F;110F 1169 11C2;CF6F;110F 1169 11C2; 
      // (콯; 콯; 콯; 콯; 콯; ) HANGUL SYLLABLE KOH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF6F }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF6F }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x1169, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF6F }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_088)
  {
      // CF70;CF70;110F 116A;CF70;110F 116A; 
      // (콰; 콰; 콰; 콰; 콰; ) HANGUL SYLLABLE KWA
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF70 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF70 }};
          std::array<uint32_t, 2> const c3 = {{ 0x110F, 0x116A }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF70 }};
          std::array<uint32_t, 2> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_089)
  {
      // CF71;CF71;110F 116A 11A8;CF71;110F 116A 11A8; 
      // (콱; 콱; 콱; 콱; 콱; ) HANGUL SYLLABLE KWAG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF71 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF71 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF71 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_090)
  {
      // CF72;CF72;110F 116A 11A9;CF72;110F 116A 11A9; 
      // (콲; 콲; 콲; 콲; 콲; ) HANGUL SYLLABLE KWAGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF72 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF72 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF72 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_091)
  {
      // CF73;CF73;110F 116A 11AA;CF73;110F 116A 11AA; 
      // (콳; 콳; 콳; 콳; 콳; ) HANGUL SYLLABLE KWAGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF73 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF73 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF73 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_092)
  {
      // CF74;CF74;110F 116A 11AB;CF74;110F 116A 11AB; 
      // (콴; 콴; 콴; 콴; 콴; ) HANGUL SYLLABLE KWAN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF74 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF74 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF74 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_093)
  {
      // CF75;CF75;110F 116A 11AC;CF75;110F 116A 11AC; 
      // (콵; 콵; 콵; 콵; 콵; ) HANGUL SYLLABLE KWANJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF75 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF75 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF75 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_094)
  {
      // CF76;CF76;110F 116A 11AD;CF76;110F 116A 11AD; 
      // (콶; 콶; 콶; 콶; 콶; ) HANGUL SYLLABLE KWANH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF76 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF76 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF76 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_095)
  {
      // CF77;CF77;110F 116A 11AE;CF77;110F 116A 11AE; 
      // (콷; 콷; 콷; 콷; 콷; ) HANGUL SYLLABLE KWAD
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF77 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF77 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF77 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_096)
  {
      // CF78;CF78;110F 116A 11AF;CF78;110F 116A 11AF; 
      // (콸; 콸; 콸; 콸; 콸; ) HANGUL SYLLABLE KWAL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF78 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF78 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF78 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_097)
  {
      // CF79;CF79;110F 116A 11B0;CF79;110F 116A 11B0; 
      // (콹; 콹; 콹; 콹; 콹; ) HANGUL SYLLABLE KWALG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF79 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF79 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF79 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_098)
  {
      // CF7A;CF7A;110F 116A 11B1;CF7A;110F 116A 11B1; 
      // (콺; 콺; 콺; 콺; 콺; ) HANGUL SYLLABLE KWALM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF7A }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF7A }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF7A }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_099)
  {
      // CF7B;CF7B;110F 116A 11B2;CF7B;110F 116A 11B2; 
      // (콻; 콻; 콻; 콻; 콻; ) HANGUL SYLLABLE KWALB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF7B }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF7B }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF7B }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_100)
  {
      // CF7C;CF7C;110F 116A 11B3;CF7C;110F 116A 11B3; 
      // (콼; 콼; 콼; 콼; 콼; ) HANGUL SYLLABLE KWALS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF7C }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF7C }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF7C }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_101)
  {
      // CF7D;CF7D;110F 116A 11B4;CF7D;110F 116A 11B4; 
      // (콽; 콽; 콽; 콽; 콽; ) HANGUL SYLLABLE KWALT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF7D }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF7D }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF7D }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_102)
  {
      // CF7E;CF7E;110F 116A 11B5;CF7E;110F 116A 11B5; 
      // (콾; 콾; 콾; 콾; 콾; ) HANGUL SYLLABLE KWALP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF7E }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF7E }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF7E }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_103)
  {
      // CF7F;CF7F;110F 116A 11B6;CF7F;110F 116A 11B6; 
      // (콿; 콿; 콿; 콿; 콿; ) HANGUL SYLLABLE KWALH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF7F }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF7F }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF7F }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_104)
  {
      // CF80;CF80;110F 116A 11B7;CF80;110F 116A 11B7; 
      // (쾀; 쾀; 쾀; 쾀; 쾀; ) HANGUL SYLLABLE KWAM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF80 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF80 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF80 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_105)
  {
      // CF81;CF81;110F 116A 11B8;CF81;110F 116A 11B8; 
      // (쾁; 쾁; 쾁; 쾁; 쾁; ) HANGUL SYLLABLE KWAB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF81 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF81 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF81 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_106)
  {
      // CF82;CF82;110F 116A 11B9;CF82;110F 116A 11B9; 
      // (쾂; 쾂; 쾂; 쾂; 쾂; ) HANGUL SYLLABLE KWABS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF82 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF82 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF82 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_107)
  {
      // CF83;CF83;110F 116A 11BA;CF83;110F 116A 11BA; 
      // (쾃; 쾃; 쾃; 쾃; 쾃; ) HANGUL SYLLABLE KWAS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF83 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF83 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF83 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_108)
  {
      // CF84;CF84;110F 116A 11BB;CF84;110F 116A 11BB; 
      // (쾄; 쾄; 쾄; 쾄; 쾄; ) HANGUL SYLLABLE KWASS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF84 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF84 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF84 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_109)
  {
      // CF85;CF85;110F 116A 11BC;CF85;110F 116A 11BC; 
      // (쾅; 쾅; 쾅; 쾅; 쾅; ) HANGUL SYLLABLE KWANG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF85 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF85 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF85 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_110)
  {
      // CF86;CF86;110F 116A 11BD;CF86;110F 116A 11BD; 
      // (쾆; 쾆; 쾆; 쾆; 쾆; ) HANGUL SYLLABLE KWAJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF86 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF86 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF86 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_111)
  {
      // CF87;CF87;110F 116A 11BE;CF87;110F 116A 11BE; 
      // (쾇; 쾇; 쾇; 쾇; 쾇; ) HANGUL SYLLABLE KWAC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF87 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF87 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF87 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_112)
  {
      // CF88;CF88;110F 116A 11BF;CF88;110F 116A 11BF; 
      // (쾈; 쾈; 쾈; 쾈; 쾈; ) HANGUL SYLLABLE KWAK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF88 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF88 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF88 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_113)
  {
      // CF89;CF89;110F 116A 11C0;CF89;110F 116A 11C0; 
      // (쾉; 쾉; 쾉; 쾉; 쾉; ) HANGUL SYLLABLE KWAT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF89 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF89 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF89 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_114)
  {
      // CF8A;CF8A;110F 116A 11C1;CF8A;110F 116A 11C1; 
      // (쾊; 쾊; 쾊; 쾊; 쾊; ) HANGUL SYLLABLE KWAP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF8A }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF8A }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF8A }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_115)
  {
      // CF8B;CF8B;110F 116A 11C2;CF8B;110F 116A 11C2; 
      // (쾋; 쾋; 쾋; 쾋; 쾋; ) HANGUL SYLLABLE KWAH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF8B }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF8B }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116A, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF8B }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_116)
  {
      // CF8C;CF8C;110F 116B;CF8C;110F 116B; 
      // (쾌; 쾌; 쾌; 쾌; 쾌; ) HANGUL SYLLABLE KWAE
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF8C }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF8C }};
          std::array<uint32_t, 2> const c3 = {{ 0x110F, 0x116B }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF8C }};
          std::array<uint32_t, 2> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_117)
  {
      // CF8D;CF8D;110F 116B 11A8;CF8D;110F 116B 11A8; 
      // (쾍; 쾍; 쾍; 쾍; 쾍; ) HANGUL SYLLABLE KWAEG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF8D }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF8D }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF8D }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_118)
  {
      // CF8E;CF8E;110F 116B 11A9;CF8E;110F 116B 11A9; 
      // (쾎; 쾎; 쾎; 쾎; 쾎; ) HANGUL SYLLABLE KWAEGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF8E }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF8E }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF8E }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_119)
  {
      // CF8F;CF8F;110F 116B 11AA;CF8F;110F 116B 11AA; 
      // (쾏; 쾏; 쾏; 쾏; 쾏; ) HANGUL SYLLABLE KWAEGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF8F }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF8F }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF8F }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_120)
  {
      // CF90;CF90;110F 116B 11AB;CF90;110F 116B 11AB; 
      // (쾐; 쾐; 쾐; 쾐; 쾐; ) HANGUL SYLLABLE KWAEN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF90 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF90 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF90 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_121)
  {
      // CF91;CF91;110F 116B 11AC;CF91;110F 116B 11AC; 
      // (쾑; 쾑; 쾑; 쾑; 쾑; ) HANGUL SYLLABLE KWAENJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF91 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF91 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF91 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_122)
  {
      // CF92;CF92;110F 116B 11AD;CF92;110F 116B 11AD; 
      // (쾒; 쾒; 쾒; 쾒; 쾒; ) HANGUL SYLLABLE KWAENH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF92 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF92 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF92 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_123)
  {
      // CF93;CF93;110F 116B 11AE;CF93;110F 116B 11AE; 
      // (쾓; 쾓; 쾓; 쾓; 쾓; ) HANGUL SYLLABLE KWAED
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF93 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF93 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF93 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_124)
  {
      // CF94;CF94;110F 116B 11AF;CF94;110F 116B 11AF; 
      // (쾔; 쾔; 쾔; 쾔; 쾔; ) HANGUL SYLLABLE KWAEL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF94 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF94 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF94 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_125)
  {
      // CF95;CF95;110F 116B 11B0;CF95;110F 116B 11B0; 
      // (쾕; 쾕; 쾕; 쾕; 쾕; ) HANGUL SYLLABLE KWAELG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF95 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF95 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF95 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_126)
  {
      // CF96;CF96;110F 116B 11B1;CF96;110F 116B 11B1; 
      // (쾖; 쾖; 쾖; 쾖; 쾖; ) HANGUL SYLLABLE KWAELM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF96 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF96 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF96 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_127)
  {
      // CF97;CF97;110F 116B 11B2;CF97;110F 116B 11B2; 
      // (쾗; 쾗; 쾗; 쾗; 쾗; ) HANGUL SYLLABLE KWAELB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF97 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF97 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF97 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_128)
  {
      // CF98;CF98;110F 116B 11B3;CF98;110F 116B 11B3; 
      // (쾘; 쾘; 쾘; 쾘; 쾘; ) HANGUL SYLLABLE KWAELS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF98 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF98 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF98 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_129)
  {
      // CF99;CF99;110F 116B 11B4;CF99;110F 116B 11B4; 
      // (쾙; 쾙; 쾙; 쾙; 쾙; ) HANGUL SYLLABLE KWAELT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF99 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF99 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF99 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_130)
  {
      // CF9A;CF9A;110F 116B 11B5;CF9A;110F 116B 11B5; 
      // (쾚; 쾚; 쾚; 쾚; 쾚; ) HANGUL SYLLABLE KWAELP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF9A }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF9A }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF9A }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_131)
  {
      // CF9B;CF9B;110F 116B 11B6;CF9B;110F 116B 11B6; 
      // (쾛; 쾛; 쾛; 쾛; 쾛; ) HANGUL SYLLABLE KWAELH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF9B }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF9B }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF9B }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_132)
  {
      // CF9C;CF9C;110F 116B 11B7;CF9C;110F 116B 11B7; 
      // (쾜; 쾜; 쾜; 쾜; 쾜; ) HANGUL SYLLABLE KWAEM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF9C }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF9C }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF9C }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_133)
  {
      // CF9D;CF9D;110F 116B 11B8;CF9D;110F 116B 11B8; 
      // (쾝; 쾝; 쾝; 쾝; 쾝; ) HANGUL SYLLABLE KWAEB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF9D }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF9D }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF9D }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_134)
  {
      // CF9E;CF9E;110F 116B 11B9;CF9E;110F 116B 11B9; 
      // (쾞; 쾞; 쾞; 쾞; 쾞; ) HANGUL SYLLABLE KWAEBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF9E }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF9E }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF9E }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_135)
  {
      // CF9F;CF9F;110F 116B 11BA;CF9F;110F 116B 11BA; 
      // (쾟; 쾟; 쾟; 쾟; 쾟; ) HANGUL SYLLABLE KWAES
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCF9F }};
          std::array<uint32_t, 1> const c2 = {{ 0xCF9F }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xCF9F }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_136)
  {
      // CFA0;CFA0;110F 116B 11BB;CFA0;110F 116B 11BB; 
      // (쾠; 쾠; 쾠; 쾠; 쾠; ) HANGUL SYLLABLE KWAESS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFA0 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFA0 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFA0 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_137)
  {
      // CFA1;CFA1;110F 116B 11BC;CFA1;110F 116B 11BC; 
      // (쾡; 쾡; 쾡; 쾡; 쾡; ) HANGUL SYLLABLE KWAENG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFA1 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFA1 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFA1 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_138)
  {
      // CFA2;CFA2;110F 116B 11BD;CFA2;110F 116B 11BD; 
      // (쾢; 쾢; 쾢; 쾢; 쾢; ) HANGUL SYLLABLE KWAEJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFA2 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFA2 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFA2 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_139)
  {
      // CFA3;CFA3;110F 116B 11BE;CFA3;110F 116B 11BE; 
      // (쾣; 쾣; 쾣; 쾣; 쾣; ) HANGUL SYLLABLE KWAEC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFA3 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFA3 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFA3 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_140)
  {
      // CFA4;CFA4;110F 116B 11BF;CFA4;110F 116B 11BF; 
      // (쾤; 쾤; 쾤; 쾤; 쾤; ) HANGUL SYLLABLE KWAEK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFA4 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFA4 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFA4 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_141)
  {
      // CFA5;CFA5;110F 116B 11C0;CFA5;110F 116B 11C0; 
      // (쾥; 쾥; 쾥; 쾥; 쾥; ) HANGUL SYLLABLE KWAET
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFA5 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFA5 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFA5 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_142)
  {
      // CFA6;CFA6;110F 116B 11C1;CFA6;110F 116B 11C1; 
      // (쾦; 쾦; 쾦; 쾦; 쾦; ) HANGUL SYLLABLE KWAEP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFA6 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFA6 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFA6 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_143)
  {
      // CFA7;CFA7;110F 116B 11C2;CFA7;110F 116B 11C2; 
      // (쾧; 쾧; 쾧; 쾧; 쾧; ) HANGUL SYLLABLE KWAEH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFA7 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFA7 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116B, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFA7 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_144)
  {
      // CFA8;CFA8;110F 116C;CFA8;110F 116C; 
      // (쾨; 쾨; 쾨; 쾨; 쾨; ) HANGUL SYLLABLE KOE
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFA8 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFA8 }};
          std::array<uint32_t, 2> const c3 = {{ 0x110F, 0x116C }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFA8 }};
          std::array<uint32_t, 2> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_145)
  {
      // CFA9;CFA9;110F 116C 11A8;CFA9;110F 116C 11A8; 
      // (쾩; 쾩; 쾩; 쾩; 쾩; ) HANGUL SYLLABLE KOEG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFA9 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFA9 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFA9 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_146)
  {
      // CFAA;CFAA;110F 116C 11A9;CFAA;110F 116C 11A9; 
      // (쾪; 쾪; 쾪; 쾪; 쾪; ) HANGUL SYLLABLE KOEGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFAA }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFAA }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFAA }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_147)
  {
      // CFAB;CFAB;110F 116C 11AA;CFAB;110F 116C 11AA; 
      // (쾫; 쾫; 쾫; 쾫; 쾫; ) HANGUL SYLLABLE KOEGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFAB }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFAB }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFAB }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_148)
  {
      // CFAC;CFAC;110F 116C 11AB;CFAC;110F 116C 11AB; 
      // (쾬; 쾬; 쾬; 쾬; 쾬; ) HANGUL SYLLABLE KOEN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFAC }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFAC }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFAC }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_149)
  {
      // CFAD;CFAD;110F 116C 11AC;CFAD;110F 116C 11AC; 
      // (쾭; 쾭; 쾭; 쾭; 쾭; ) HANGUL SYLLABLE KOENJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFAD }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFAD }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFAD }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_150)
  {
      // CFAE;CFAE;110F 116C 11AD;CFAE;110F 116C 11AD; 
      // (쾮; 쾮; 쾮; 쾮; 쾮; ) HANGUL SYLLABLE KOENH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFAE }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFAE }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFAE }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_151)
  {
      // CFAF;CFAF;110F 116C 11AE;CFAF;110F 116C 11AE; 
      // (쾯; 쾯; 쾯; 쾯; 쾯; ) HANGUL SYLLABLE KOED
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFAF }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFAF }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFAF }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_152)
  {
      // CFB0;CFB0;110F 116C 11AF;CFB0;110F 116C 11AF; 
      // (쾰; 쾰; 쾰; 쾰; 쾰; ) HANGUL SYLLABLE KOEL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFB0 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFB0 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFB0 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_153)
  {
      // CFB1;CFB1;110F 116C 11B0;CFB1;110F 116C 11B0; 
      // (쾱; 쾱; 쾱; 쾱; 쾱; ) HANGUL SYLLABLE KOELG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFB1 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFB1 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFB1 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_154)
  {
      // CFB2;CFB2;110F 116C 11B1;CFB2;110F 116C 11B1; 
      // (쾲; 쾲; 쾲; 쾲; 쾲; ) HANGUL SYLLABLE KOELM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFB2 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFB2 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFB2 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_155)
  {
      // CFB3;CFB3;110F 116C 11B2;CFB3;110F 116C 11B2; 
      // (쾳; 쾳; 쾳; 쾳; 쾳; ) HANGUL SYLLABLE KOELB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFB3 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFB3 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFB3 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_156)
  {
      // CFB4;CFB4;110F 116C 11B3;CFB4;110F 116C 11B3; 
      // (쾴; 쾴; 쾴; 쾴; 쾴; ) HANGUL SYLLABLE KOELS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFB4 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFB4 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFB4 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_157)
  {
      // CFB5;CFB5;110F 116C 11B4;CFB5;110F 116C 11B4; 
      // (쾵; 쾵; 쾵; 쾵; 쾵; ) HANGUL SYLLABLE KOELT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFB5 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFB5 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFB5 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_158)
  {
      // CFB6;CFB6;110F 116C 11B5;CFB6;110F 116C 11B5; 
      // (쾶; 쾶; 쾶; 쾶; 쾶; ) HANGUL SYLLABLE KOELP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFB6 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFB6 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFB6 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_159)
  {
      // CFB7;CFB7;110F 116C 11B6;CFB7;110F 116C 11B6; 
      // (쾷; 쾷; 쾷; 쾷; 쾷; ) HANGUL SYLLABLE KOELH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFB7 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFB7 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFB7 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_160)
  {
      // CFB8;CFB8;110F 116C 11B7;CFB8;110F 116C 11B7; 
      // (쾸; 쾸; 쾸; 쾸; 쾸; ) HANGUL SYLLABLE KOEM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFB8 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFB8 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFB8 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_161)
  {
      // CFB9;CFB9;110F 116C 11B8;CFB9;110F 116C 11B8; 
      // (쾹; 쾹; 쾹; 쾹; 쾹; ) HANGUL SYLLABLE KOEB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFB9 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFB9 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFB9 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_162)
  {
      // CFBA;CFBA;110F 116C 11B9;CFBA;110F 116C 11B9; 
      // (쾺; 쾺; 쾺; 쾺; 쾺; ) HANGUL SYLLABLE KOEBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFBA }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFBA }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFBA }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_163)
  {
      // CFBB;CFBB;110F 116C 11BA;CFBB;110F 116C 11BA; 
      // (쾻; 쾻; 쾻; 쾻; 쾻; ) HANGUL SYLLABLE KOES
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFBB }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFBB }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFBB }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_164)
  {
      // CFBC;CFBC;110F 116C 11BB;CFBC;110F 116C 11BB; 
      // (쾼; 쾼; 쾼; 쾼; 쾼; ) HANGUL SYLLABLE KOESS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFBC }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFBC }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFBC }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_165)
  {
      // CFBD;CFBD;110F 116C 11BC;CFBD;110F 116C 11BC; 
      // (쾽; 쾽; 쾽; 쾽; 쾽; ) HANGUL SYLLABLE KOENG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFBD }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFBD }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFBD }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_166)
  {
      // CFBE;CFBE;110F 116C 11BD;CFBE;110F 116C 11BD; 
      // (쾾; 쾾; 쾾; 쾾; 쾾; ) HANGUL SYLLABLE KOEJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFBE }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFBE }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFBE }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_167)
  {
      // CFBF;CFBF;110F 116C 11BE;CFBF;110F 116C 11BE; 
      // (쾿; 쾿; 쾿; 쾿; 쾿; ) HANGUL SYLLABLE KOEC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFBF }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFBF }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFBF }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_168)
  {
      // CFC0;CFC0;110F 116C 11BF;CFC0;110F 116C 11BF; 
      // (쿀; 쿀; 쿀; 쿀; 쿀; ) HANGUL SYLLABLE KOEK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFC0 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFC0 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFC0 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_169)
  {
      // CFC1;CFC1;110F 116C 11C0;CFC1;110F 116C 11C0; 
      // (쿁; 쿁; 쿁; 쿁; 쿁; ) HANGUL SYLLABLE KOET
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFC1 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFC1 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFC1 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_170)
  {
      // CFC2;CFC2;110F 116C 11C1;CFC2;110F 116C 11C1; 
      // (쿂; 쿂; 쿂; 쿂; 쿂; ) HANGUL SYLLABLE KOEP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFC2 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFC2 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFC2 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_171)
  {
      // CFC3;CFC3;110F 116C 11C2;CFC3;110F 116C 11C2; 
      // (쿃; 쿃; 쿃; 쿃; 쿃; ) HANGUL SYLLABLE KOEH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFC3 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFC3 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116C, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFC3 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_172)
  {
      // CFC4;CFC4;110F 116D;CFC4;110F 116D; 
      // (쿄; 쿄; 쿄; 쿄; 쿄; ) HANGUL SYLLABLE KYO
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFC4 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFC4 }};
          std::array<uint32_t, 2> const c3 = {{ 0x110F, 0x116D }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFC4 }};
          std::array<uint32_t, 2> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_173)
  {
      // CFC5;CFC5;110F 116D 11A8;CFC5;110F 116D 11A8; 
      // (쿅; 쿅; 쿅; 쿅; 쿅; ) HANGUL SYLLABLE KYOG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFC5 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFC5 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFC5 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_174)
  {
      // CFC6;CFC6;110F 116D 11A9;CFC6;110F 116D 11A9; 
      // (쿆; 쿆; 쿆; 쿆; 쿆; ) HANGUL SYLLABLE KYOGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFC6 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFC6 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFC6 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_175)
  {
      // CFC7;CFC7;110F 116D 11AA;CFC7;110F 116D 11AA; 
      // (쿇; 쿇; 쿇; 쿇; 쿇; ) HANGUL SYLLABLE KYOGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFC7 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFC7 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFC7 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_176)
  {
      // CFC8;CFC8;110F 116D 11AB;CFC8;110F 116D 11AB; 
      // (쿈; 쿈; 쿈; 쿈; 쿈; ) HANGUL SYLLABLE KYON
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFC8 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFC8 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFC8 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_177)
  {
      // CFC9;CFC9;110F 116D 11AC;CFC9;110F 116D 11AC; 
      // (쿉; 쿉; 쿉; 쿉; 쿉; ) HANGUL SYLLABLE KYONJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFC9 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFC9 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFC9 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_178)
  {
      // CFCA;CFCA;110F 116D 11AD;CFCA;110F 116D 11AD; 
      // (쿊; 쿊; 쿊; 쿊; 쿊; ) HANGUL SYLLABLE KYONH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFCA }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFCA }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFCA }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_179)
  {
      // CFCB;CFCB;110F 116D 11AE;CFCB;110F 116D 11AE; 
      // (쿋; 쿋; 쿋; 쿋; 쿋; ) HANGUL SYLLABLE KYOD
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFCB }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFCB }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFCB }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_180)
  {
      // CFCC;CFCC;110F 116D 11AF;CFCC;110F 116D 11AF; 
      // (쿌; 쿌; 쿌; 쿌; 쿌; ) HANGUL SYLLABLE KYOL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFCC }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFCC }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFCC }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_181)
  {
      // CFCD;CFCD;110F 116D 11B0;CFCD;110F 116D 11B0; 
      // (쿍; 쿍; 쿍; 쿍; 쿍; ) HANGUL SYLLABLE KYOLG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFCD }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFCD }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFCD }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_182)
  {
      // CFCE;CFCE;110F 116D 11B1;CFCE;110F 116D 11B1; 
      // (쿎; 쿎; 쿎; 쿎; 쿎; ) HANGUL SYLLABLE KYOLM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFCE }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFCE }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFCE }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_183)
  {
      // CFCF;CFCF;110F 116D 11B2;CFCF;110F 116D 11B2; 
      // (쿏; 쿏; 쿏; 쿏; 쿏; ) HANGUL SYLLABLE KYOLB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFCF }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFCF }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFCF }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_184)
  {
      // CFD0;CFD0;110F 116D 11B3;CFD0;110F 116D 11B3; 
      // (쿐; 쿐; 쿐; 쿐; 쿐; ) HANGUL SYLLABLE KYOLS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFD0 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFD0 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFD0 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_185)
  {
      // CFD1;CFD1;110F 116D 11B4;CFD1;110F 116D 11B4; 
      // (쿑; 쿑; 쿑; 쿑; 쿑; ) HANGUL SYLLABLE KYOLT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFD1 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFD1 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFD1 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_186)
  {
      // CFD2;CFD2;110F 116D 11B5;CFD2;110F 116D 11B5; 
      // (쿒; 쿒; 쿒; 쿒; 쿒; ) HANGUL SYLLABLE KYOLP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFD2 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFD2 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFD2 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_187)
  {
      // CFD3;CFD3;110F 116D 11B6;CFD3;110F 116D 11B6; 
      // (쿓; 쿓; 쿓; 쿓; 쿓; ) HANGUL SYLLABLE KYOLH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFD3 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFD3 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFD3 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_188)
  {
      // CFD4;CFD4;110F 116D 11B7;CFD4;110F 116D 11B7; 
      // (쿔; 쿔; 쿔; 쿔; 쿔; ) HANGUL SYLLABLE KYOM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFD4 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFD4 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFD4 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_189)
  {
      // CFD5;CFD5;110F 116D 11B8;CFD5;110F 116D 11B8; 
      // (쿕; 쿕; 쿕; 쿕; 쿕; ) HANGUL SYLLABLE KYOB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFD5 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFD5 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFD5 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_190)
  {
      // CFD6;CFD6;110F 116D 11B9;CFD6;110F 116D 11B9; 
      // (쿖; 쿖; 쿖; 쿖; 쿖; ) HANGUL SYLLABLE KYOBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFD6 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFD6 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFD6 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_191)
  {
      // CFD7;CFD7;110F 116D 11BA;CFD7;110F 116D 11BA; 
      // (쿗; 쿗; 쿗; 쿗; 쿗; ) HANGUL SYLLABLE KYOS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFD7 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFD7 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFD7 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_192)
  {
      // CFD8;CFD8;110F 116D 11BB;CFD8;110F 116D 11BB; 
      // (쿘; 쿘; 쿘; 쿘; 쿘; ) HANGUL SYLLABLE KYOSS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFD8 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFD8 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFD8 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_193)
  {
      // CFD9;CFD9;110F 116D 11BC;CFD9;110F 116D 11BC; 
      // (쿙; 쿙; 쿙; 쿙; 쿙; ) HANGUL SYLLABLE KYONG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFD9 }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFD9 }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFD9 }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_194)
  {
      // CFDA;CFDA;110F 116D 11BD;CFDA;110F 116D 11BD; 
      // (쿚; 쿚; 쿚; 쿚; 쿚; ) HANGUL SYLLABLE KYOJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFDA }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFDA }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFDA }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_195)
  {
      // CFDB;CFDB;110F 116D 11BE;CFDB;110F 116D 11BE; 
      // (쿛; 쿛; 쿛; 쿛; 쿛; ) HANGUL SYLLABLE KYOC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFDB }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFDB }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFDB }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_196)
  {
      // CFDC;CFDC;110F 116D 11BF;CFDC;110F 116D 11BF; 
      // (쿜; 쿜; 쿜; 쿜; 쿜; ) HANGUL SYLLABLE KYOK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFDC }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFDC }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFDC }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_197)
  {
      // CFDD;CFDD;110F 116D 11C0;CFDD;110F 116D 11C0; 
      // (쿝; 쿝; 쿝; 쿝; 쿝; ) HANGUL SYLLABLE KYOT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFDD }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFDD }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFDD }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_198)
  {
      // CFDE;CFDE;110F 116D 11C1;CFDE;110F 116D 11C1; 
      // (쿞; 쿞; 쿞; 쿞; 쿞; ) HANGUL SYLLABLE KYOP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFDE }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFDE }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFDE }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)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, nfc_057_199)
  {
      // CFDF;CFDF;110F 116D 11C2;CFDF;110F 116D 11C2; 
      // (쿟; 쿟; 쿟; 쿟; 쿟; ) HANGUL SYLLABLE KYOH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xCFDF }};
          std::array<uint32_t, 1> const c2 = {{ 0xCFDF }};
          std::array<uint32_t, 3> const c3 = {{ 0x110F, 0x116D, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xCFDF }};
          std::array<uint32_t, 3> const c5 = {{ 0x110F, 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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              std::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize<boost::text::nf::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              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::c>(str);
              auto const r = boost::text::as_utf32(str);
              EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : r) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  