text:
// 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, nfkd_080_000)
{
    // 1D76A;1D76A;1D76A;03A5;03A5;
    // (𝝪; 𝝪; 𝝪; Υ; Υ; ) MATHEMATICAL SANS-SERIF BOLD CAPITAL UPSILON
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D76A }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D76A }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D76A }};
        std::array<uint32_t, 1> const c4 = {{ 0x03A5 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03A5 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_001)
{
    // 1D76B;1D76B;1D76B;03A6;03A6;
    // (𝝫; 𝝫; 𝝫; Φ; Φ; ) MATHEMATICAL SANS-SERIF BOLD CAPITAL PHI
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D76B }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D76B }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D76B }};
        std::array<uint32_t, 1> const c4 = {{ 0x03A6 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03A6 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_002)
{
    // 1D76C;1D76C;1D76C;03A7;03A7;
    // (𝝬; 𝝬; 𝝬; Χ; Χ; ) MATHEMATICAL SANS-SERIF BOLD CAPITAL CHI
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D76C }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D76C }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D76C }};
        std::array<uint32_t, 1> const c4 = {{ 0x03A7 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03A7 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_003)
{
    // 1D76D;1D76D;1D76D;03A8;03A8;
    // (𝝭; 𝝭; 𝝭; Ψ; Ψ; ) MATHEMATICAL SANS-SERIF BOLD CAPITAL PSI
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D76D }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D76D }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D76D }};
        std::array<uint32_t, 1> const c4 = {{ 0x03A8 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03A8 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_004)
{
    // 1D76E;1D76E;1D76E;03A9;03A9;
    // (𝝮; 𝝮; 𝝮; Ω; Ω; ) MATHEMATICAL SANS-SERIF BOLD CAPITAL OMEGA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D76E }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D76E }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D76E }};
        std::array<uint32_t, 1> const c4 = {{ 0x03A9 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03A9 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_005)
{
    // 1D76F;1D76F;1D76F;2207;2207;
    // (𝝯; 𝝯; 𝝯; ∇; ∇; ) MATHEMATICAL SANS-SERIF BOLD NABLA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D76F }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D76F }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D76F }};
        std::array<uint32_t, 1> const c4 = {{ 0x2207 }};
        std::array<uint32_t, 1> const c5 = {{ 0x2207 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_006)
{
    // 1D770;1D770;1D770;03B1;03B1;
    // (𝝰; 𝝰; 𝝰; α; α; ) MATHEMATICAL SANS-SERIF BOLD SMALL ALPHA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D770 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D770 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D770 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03B1 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03B1 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_007)
{
    // 1D771;1D771;1D771;03B2;03B2;
    // (𝝱; 𝝱; 𝝱; β; β; ) MATHEMATICAL SANS-SERIF BOLD SMALL BETA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D771 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D771 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D771 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03B2 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03B2 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_008)
{
    // 1D772;1D772;1D772;03B3;03B3;
    // (𝝲; 𝝲; 𝝲; γ; γ; ) MATHEMATICAL SANS-SERIF BOLD SMALL GAMMA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D772 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D772 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D772 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03B3 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03B3 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_009)
{
    // 1D773;1D773;1D773;03B4;03B4;
    // (𝝳; 𝝳; 𝝳; δ; δ; ) MATHEMATICAL SANS-SERIF BOLD SMALL DELTA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D773 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D773 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D773 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03B4 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03B4 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_010)
{
    // 1D774;1D774;1D774;03B5;03B5;
    // (𝝴; 𝝴; 𝝴; ε; ε; ) MATHEMATICAL SANS-SERIF BOLD SMALL EPSILON
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D774 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D774 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D774 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03B5 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03B5 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_011)
{
    // 1D775;1D775;1D775;03B6;03B6;
    // (𝝵; 𝝵; 𝝵; ζ; ζ; ) MATHEMATICAL SANS-SERIF BOLD SMALL ZETA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D775 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D775 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D775 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03B6 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03B6 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_012)
{
    // 1D776;1D776;1D776;03B7;03B7;
    // (𝝶; 𝝶; 𝝶; η; η; ) MATHEMATICAL SANS-SERIF BOLD SMALL ETA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D776 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D776 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D776 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03B7 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03B7 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_013)
{
    // 1D777;1D777;1D777;03B8;03B8;
    // (𝝷; 𝝷; 𝝷; θ; θ; ) MATHEMATICAL SANS-SERIF BOLD SMALL THETA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D777 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D777 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D777 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03B8 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03B8 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_014)
{
    // 1D778;1D778;1D778;03B9;03B9;
    // (𝝸; 𝝸; 𝝸; ι; ι; ) MATHEMATICAL SANS-SERIF BOLD SMALL IOTA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D778 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D778 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D778 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03B9 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03B9 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_015)
{
    // 1D779;1D779;1D779;03BA;03BA;
    // (𝝹; 𝝹; 𝝹; κ; κ; ) MATHEMATICAL SANS-SERIF BOLD SMALL KAPPA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D779 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D779 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D779 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03BA }};
        std::array<uint32_t, 1> const c5 = {{ 0x03BA }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_016)
{
    // 1D77A;1D77A;1D77A;03BB;03BB;
    // (𝝺; 𝝺; 𝝺; λ; λ; ) MATHEMATICAL SANS-SERIF BOLD SMALL LAMDA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D77A }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D77A }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D77A }};
        std::array<uint32_t, 1> const c4 = {{ 0x03BB }};
        std::array<uint32_t, 1> const c5 = {{ 0x03BB }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_017)
{
    // 1D77B;1D77B;1D77B;03BC;03BC;
    // (𝝻; 𝝻; 𝝻; μ; μ; ) MATHEMATICAL SANS-SERIF BOLD SMALL MU
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D77B }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D77B }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D77B }};
        std::array<uint32_t, 1> const c4 = {{ 0x03BC }};
        std::array<uint32_t, 1> const c5 = {{ 0x03BC }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_018)
{
    // 1D77C;1D77C;1D77C;03BD;03BD;
    // (𝝼; 𝝼; 𝝼; ν; ν; ) MATHEMATICAL SANS-SERIF BOLD SMALL NU
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D77C }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D77C }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D77C }};
        std::array<uint32_t, 1> const c4 = {{ 0x03BD }};
        std::array<uint32_t, 1> const c5 = {{ 0x03BD }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_019)
{
    // 1D77D;1D77D;1D77D;03BE;03BE;
    // (𝝽; 𝝽; 𝝽; ξ; ξ; ) MATHEMATICAL SANS-SERIF BOLD SMALL XI
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D77D }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D77D }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D77D }};
        std::array<uint32_t, 1> const c4 = {{ 0x03BE }};
        std::array<uint32_t, 1> const c5 = {{ 0x03BE }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_020)
{
    // 1D77E;1D77E;1D77E;03BF;03BF;
    // (𝝾; 𝝾; 𝝾; ο; ο; ) MATHEMATICAL SANS-SERIF BOLD SMALL OMICRON
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D77E }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D77E }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D77E }};
        std::array<uint32_t, 1> const c4 = {{ 0x03BF }};
        std::array<uint32_t, 1> const c5 = {{ 0x03BF }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_021)
{
    // 1D77F;1D77F;1D77F;03C0;03C0;
    // (𝝿; 𝝿; 𝝿; π; π; ) MATHEMATICAL SANS-SERIF BOLD SMALL PI
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D77F }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D77F }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D77F }};
        std::array<uint32_t, 1> const c4 = {{ 0x03C0 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03C0 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_022)
{
    // 1D780;1D780;1D780;03C1;03C1;
    // (𝞀; 𝞀; 𝞀; ρ; ρ; ) MATHEMATICAL SANS-SERIF BOLD SMALL RHO
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D780 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D780 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D780 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03C1 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03C1 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_023)
{
    // 1D781;1D781;1D781;03C2;03C2;
    // (𝞁; 𝞁; 𝞁; ς; ς; ) MATHEMATICAL SANS-SERIF BOLD SMALL FINAL SIGMA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D781 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D781 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D781 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03C2 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03C2 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_024)
{
    // 1D782;1D782;1D782;03C3;03C3;
    // (𝞂; 𝞂; 𝞂; σ; σ; ) MATHEMATICAL SANS-SERIF BOLD SMALL SIGMA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D782 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D782 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D782 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03C3 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03C3 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_025)
{
    // 1D783;1D783;1D783;03C4;03C4;
    // (𝞃; 𝞃; 𝞃; τ; τ; ) MATHEMATICAL SANS-SERIF BOLD SMALL TAU
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D783 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D783 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D783 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03C4 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03C4 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_026)
{
    // 1D784;1D784;1D784;03C5;03C5;
    // (𝞄; 𝞄; 𝞄; υ; υ; ) MATHEMATICAL SANS-SERIF BOLD SMALL UPSILON
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D784 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D784 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D784 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03C5 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03C5 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_027)
{
    // 1D785;1D785;1D785;03C6;03C6;
    // (𝞅; 𝞅; 𝞅; φ; φ; ) MATHEMATICAL SANS-SERIF BOLD SMALL PHI
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D785 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D785 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D785 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03C6 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03C6 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_028)
{
    // 1D786;1D786;1D786;03C7;03C7;
    // (𝞆; 𝞆; 𝞆; χ; χ; ) MATHEMATICAL SANS-SERIF BOLD SMALL CHI
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D786 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D786 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D786 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03C7 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03C7 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_029)
{
    // 1D787;1D787;1D787;03C8;03C8;
    // (𝞇; 𝞇; 𝞇; ψ; ψ; ) MATHEMATICAL SANS-SERIF BOLD SMALL PSI
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D787 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D787 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D787 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03C8 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03C8 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_030)
{
    // 1D788;1D788;1D788;03C9;03C9;
    // (𝞈; 𝞈; 𝞈; ω; ω; ) MATHEMATICAL SANS-SERIF BOLD SMALL OMEGA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D788 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D788 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D788 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03C9 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03C9 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_031)
{
    // 1D789;1D789;1D789;2202;2202;
    // (𝞉; 𝞉; 𝞉; ∂; ∂; ) MATHEMATICAL SANS-SERIF BOLD PARTIAL DIFFERENTIAL
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D789 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D789 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D789 }};
        std::array<uint32_t, 1> const c4 = {{ 0x2202 }};
        std::array<uint32_t, 1> const c5 = {{ 0x2202 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_032)
{
    // 1D78A;1D78A;1D78A;03B5;03B5;
    // (𝞊; 𝞊; 𝞊; ε; ε; ) MATHEMATICAL SANS-SERIF BOLD EPSILON SYMBOL
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D78A }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D78A }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D78A }};
        std::array<uint32_t, 1> const c4 = {{ 0x03B5 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03B5 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_033)
{
    // 1D78B;1D78B;1D78B;03B8;03B8;
    // (𝞋; 𝞋; 𝞋; θ; θ; ) MATHEMATICAL SANS-SERIF BOLD THETA SYMBOL
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D78B }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D78B }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D78B }};
        std::array<uint32_t, 1> const c4 = {{ 0x03B8 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03B8 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_034)
{
    // 1D78C;1D78C;1D78C;03BA;03BA;
    // (𝞌; 𝞌; 𝞌; κ; κ; ) MATHEMATICAL SANS-SERIF BOLD KAPPA SYMBOL
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D78C }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D78C }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D78C }};
        std::array<uint32_t, 1> const c4 = {{ 0x03BA }};
        std::array<uint32_t, 1> const c5 = {{ 0x03BA }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_035)
{
    // 1D78D;1D78D;1D78D;03C6;03C6;
    // (𝞍; 𝞍; 𝞍; φ; φ; ) MATHEMATICAL SANS-SERIF BOLD PHI SYMBOL
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D78D }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D78D }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D78D }};
        std::array<uint32_t, 1> const c4 = {{ 0x03C6 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03C6 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_036)
{
    // 1D78E;1D78E;1D78E;03C1;03C1;
    // (𝞎; 𝞎; 𝞎; ρ; ρ; ) MATHEMATICAL SANS-SERIF BOLD RHO SYMBOL
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D78E }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D78E }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D78E }};
        std::array<uint32_t, 1> const c4 = {{ 0x03C1 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03C1 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_037)
{
    // 1D78F;1D78F;1D78F;03C0;03C0;
    // (𝞏; 𝞏; 𝞏; π; π; ) MATHEMATICAL SANS-SERIF BOLD PI SYMBOL
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D78F }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D78F }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D78F }};
        std::array<uint32_t, 1> const c4 = {{ 0x03C0 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03C0 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_038)
{
    // 1D790;1D790;1D790;0391;0391;
    // (𝞐; 𝞐; 𝞐; Α; Α; ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL ALPHA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D790 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D790 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D790 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0391 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0391 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_039)
{
    // 1D791;1D791;1D791;0392;0392;
    // (𝞑; 𝞑; 𝞑; Β; Β; ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL BETA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D791 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D791 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D791 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0392 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0392 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_040)
{
    // 1D792;1D792;1D792;0393;0393;
    // (𝞒; 𝞒; 𝞒; Γ; Γ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL GAMMA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D792 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D792 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D792 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0393 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0393 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_041)
{
    // 1D793;1D793;1D793;0394;0394;
    // (𝞓; 𝞓; 𝞓; Δ; Δ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL DELTA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D793 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D793 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D793 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0394 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0394 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_042)
{
    // 1D794;1D794;1D794;0395;0395;
    // (𝞔; 𝞔; 𝞔; Ε; Ε; ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL EPSILON
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D794 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D794 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D794 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0395 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0395 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_043)
{
    // 1D795;1D795;1D795;0396;0396;
    // (𝞕; 𝞕; 𝞕; Ζ; Ζ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL ZETA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D795 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D795 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D795 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0396 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0396 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_044)
{
    // 1D796;1D796;1D796;0397;0397;
    // (𝞖; 𝞖; 𝞖; Η; Η; ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL ETA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D796 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D796 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D796 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0397 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0397 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_045)
{
    // 1D797;1D797;1D797;0398;0398;
    // (𝞗; 𝞗; 𝞗; Θ; Θ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL THETA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D797 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D797 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D797 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0398 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0398 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_046)
{
    // 1D798;1D798;1D798;0399;0399;
    // (𝞘; 𝞘; 𝞘; Ι; Ι; ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL IOTA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D798 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D798 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D798 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0399 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0399 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_047)
{
    // 1D799;1D799;1D799;039A;039A;
    // (𝞙; 𝞙; 𝞙; Κ; Κ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL KAPPA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D799 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D799 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D799 }};
        std::array<uint32_t, 1> const c4 = {{ 0x039A }};
        std::array<uint32_t, 1> const c5 = {{ 0x039A }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_048)
{
    // 1D79A;1D79A;1D79A;039B;039B;
    // (𝞚; 𝞚; 𝞚; Λ; Λ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL LAMDA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D79A }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D79A }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D79A }};
        std::array<uint32_t, 1> const c4 = {{ 0x039B }};
        std::array<uint32_t, 1> const c5 = {{ 0x039B }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_049)
{
    // 1D79B;1D79B;1D79B;039C;039C;
    // (𝞛; 𝞛; 𝞛; Μ; Μ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL MU
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D79B }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D79B }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D79B }};
        std::array<uint32_t, 1> const c4 = {{ 0x039C }};
        std::array<uint32_t, 1> const c5 = {{ 0x039C }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_050)
{
    // 1D79C;1D79C;1D79C;039D;039D;
    // (𝞜; 𝞜; 𝞜; Ν; Ν; ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL NU
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D79C }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D79C }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D79C }};
        std::array<uint32_t, 1> const c4 = {{ 0x039D }};
        std::array<uint32_t, 1> const c5 = {{ 0x039D }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_051)
{
    // 1D79D;1D79D;1D79D;039E;039E;
    // (𝞝; 𝞝; 𝞝; Ξ; Ξ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL XI
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D79D }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D79D }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D79D }};
        std::array<uint32_t, 1> const c4 = {{ 0x039E }};
        std::array<uint32_t, 1> const c5 = {{ 0x039E }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_052)
{
    // 1D79E;1D79E;1D79E;039F;039F;
    // (𝞞; 𝞞; 𝞞; Ο; Ο; ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL OMICRON
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D79E }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D79E }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D79E }};
        std::array<uint32_t, 1> const c4 = {{ 0x039F }};
        std::array<uint32_t, 1> const c5 = {{ 0x039F }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_053)
{
    // 1D79F;1D79F;1D79F;03A0;03A0;
    // (𝞟; 𝞟; 𝞟; Π; Π; ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL PI
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D79F }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D79F }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D79F }};
        std::array<uint32_t, 1> const c4 = {{ 0x03A0 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03A0 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_054)
{
    // 1D7A0;1D7A0;1D7A0;03A1;03A1;
    // (𝞠; 𝞠; 𝞠; Ρ; Ρ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL RHO
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7A0 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7A0 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7A0 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03A1 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03A1 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_055)
{
    // 1D7A1;1D7A1;1D7A1;0398;0398;
    // (𝞡; 𝞡; 𝞡; Θ; Θ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL THETA SYMBOL
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7A1 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7A1 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7A1 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0398 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0398 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_056)
{
    // 1D7A2;1D7A2;1D7A2;03A3;03A3;
    // (𝞢; 𝞢; 𝞢; Σ; Σ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL SIGMA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7A2 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7A2 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7A2 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03A3 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03A3 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_057)
{
    // 1D7A3;1D7A3;1D7A3;03A4;03A4;
    // (𝞣; 𝞣; 𝞣; Τ; Τ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL TAU
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7A3 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7A3 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7A3 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03A4 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03A4 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_058)
{
    // 1D7A4;1D7A4;1D7A4;03A5;03A5;
    // (𝞤; 𝞤; 𝞤; Υ; Υ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL UPSILON
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7A4 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7A4 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7A4 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03A5 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03A5 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_059)
{
    // 1D7A5;1D7A5;1D7A5;03A6;03A6;
    // (𝞥; 𝞥; 𝞥; Φ; Φ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL PHI
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7A5 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7A5 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7A5 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03A6 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03A6 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_060)
{
    // 1D7A6;1D7A6;1D7A6;03A7;03A7;
    // (𝞦; 𝞦; 𝞦; Χ; Χ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL CHI
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7A6 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7A6 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7A6 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03A7 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03A7 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_061)
{
    // 1D7A7;1D7A7;1D7A7;03A8;03A8;
    // (𝞧; 𝞧; 𝞧; Ψ; Ψ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL PSI
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7A7 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7A7 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7A7 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03A8 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03A8 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_062)
{
    // 1D7A8;1D7A8;1D7A8;03A9;03A9;
    // (𝞨; 𝞨; 𝞨; Ω; Ω; ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL OMEGA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7A8 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7A8 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7A8 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03A9 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03A9 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_063)
{
    // 1D7A9;1D7A9;1D7A9;2207;2207;
    // (𝞩; 𝞩; 𝞩; ∇; ∇; ) MATHEMATICAL SANS-SERIF BOLD ITALIC NABLA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7A9 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7A9 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7A9 }};
        std::array<uint32_t, 1> const c4 = {{ 0x2207 }};
        std::array<uint32_t, 1> const c5 = {{ 0x2207 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_064)
{
    // 1D7AA;1D7AA;1D7AA;03B1;03B1;
    // (𝞪; 𝞪; 𝞪; α; α; ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ALPHA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7AA }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7AA }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7AA }};
        std::array<uint32_t, 1> const c4 = {{ 0x03B1 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03B1 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_065)
{
    // 1D7AB;1D7AB;1D7AB;03B2;03B2;
    // (𝞫; 𝞫; 𝞫; β; β; ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL BETA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7AB }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7AB }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7AB }};
        std::array<uint32_t, 1> const c4 = {{ 0x03B2 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03B2 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_066)
{
    // 1D7AC;1D7AC;1D7AC;03B3;03B3;
    // (𝞬; 𝞬; 𝞬; γ; γ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL GAMMA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7AC }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7AC }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7AC }};
        std::array<uint32_t, 1> const c4 = {{ 0x03B3 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03B3 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_067)
{
    // 1D7AD;1D7AD;1D7AD;03B4;03B4;
    // (𝞭; 𝞭; 𝞭; δ; δ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL DELTA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7AD }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7AD }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7AD }};
        std::array<uint32_t, 1> const c4 = {{ 0x03B4 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03B4 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_068)
{
    // 1D7AE;1D7AE;1D7AE;03B5;03B5;
    // (𝞮; 𝞮; 𝞮; ε; ε; ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL EPSILON
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7AE }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7AE }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7AE }};
        std::array<uint32_t, 1> const c4 = {{ 0x03B5 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03B5 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_069)
{
    // 1D7AF;1D7AF;1D7AF;03B6;03B6;
    // (𝞯; 𝞯; 𝞯; ζ; ζ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ZETA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7AF }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7AF }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7AF }};
        std::array<uint32_t, 1> const c4 = {{ 0x03B6 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03B6 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_070)
{
    // 1D7B0;1D7B0;1D7B0;03B7;03B7;
    // (𝞰; 𝞰; 𝞰; η; η; ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ETA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7B0 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7B0 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7B0 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03B7 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03B7 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_071)
{
    // 1D7B1;1D7B1;1D7B1;03B8;03B8;
    // (𝞱; 𝞱; 𝞱; θ; θ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL THETA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7B1 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7B1 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7B1 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03B8 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03B8 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_072)
{
    // 1D7B2;1D7B2;1D7B2;03B9;03B9;
    // (𝞲; 𝞲; 𝞲; ι; ι; ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL IOTA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7B2 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7B2 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7B2 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03B9 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03B9 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_073)
{
    // 1D7B3;1D7B3;1D7B3;03BA;03BA;
    // (𝞳; 𝞳; 𝞳; κ; κ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL KAPPA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7B3 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7B3 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7B3 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03BA }};
        std::array<uint32_t, 1> const c5 = {{ 0x03BA }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_074)
{
    // 1D7B4;1D7B4;1D7B4;03BB;03BB;
    // (𝞴; 𝞴; 𝞴; λ; λ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL LAMDA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7B4 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7B4 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7B4 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03BB }};
        std::array<uint32_t, 1> const c5 = {{ 0x03BB }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_075)
{
    // 1D7B5;1D7B5;1D7B5;03BC;03BC;
    // (𝞵; 𝞵; 𝞵; μ; μ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL MU
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7B5 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7B5 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7B5 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03BC }};
        std::array<uint32_t, 1> const c5 = {{ 0x03BC }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_076)
{
    // 1D7B6;1D7B6;1D7B6;03BD;03BD;
    // (𝞶; 𝞶; 𝞶; ν; ν; ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL NU
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7B6 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7B6 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7B6 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03BD }};
        std::array<uint32_t, 1> const c5 = {{ 0x03BD }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_077)
{
    // 1D7B7;1D7B7;1D7B7;03BE;03BE;
    // (𝞷; 𝞷; 𝞷; ξ; ξ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL XI
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7B7 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7B7 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7B7 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03BE }};
        std::array<uint32_t, 1> const c5 = {{ 0x03BE }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_078)
{
    // 1D7B8;1D7B8;1D7B8;03BF;03BF;
    // (𝞸; 𝞸; 𝞸; ο; ο; ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL OMICRON
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7B8 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7B8 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7B8 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03BF }};
        std::array<uint32_t, 1> const c5 = {{ 0x03BF }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_079)
{
    // 1D7B9;1D7B9;1D7B9;03C0;03C0;
    // (𝞹; 𝞹; 𝞹; π; π; ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL PI
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7B9 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7B9 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7B9 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03C0 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03C0 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_080)
{
    // 1D7BA;1D7BA;1D7BA;03C1;03C1;
    // (𝞺; 𝞺; 𝞺; ρ; ρ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL RHO
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7BA }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7BA }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7BA }};
        std::array<uint32_t, 1> const c4 = {{ 0x03C1 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03C1 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_081)
{
    // 1D7BB;1D7BB;1D7BB;03C2;03C2;
    // (𝞻; 𝞻; 𝞻; ς; ς; ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL FINAL SIGMA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7BB }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7BB }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7BB }};
        std::array<uint32_t, 1> const c4 = {{ 0x03C2 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03C2 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_082)
{
    // 1D7BC;1D7BC;1D7BC;03C3;03C3;
    // (𝞼; 𝞼; 𝞼; σ; σ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL SIGMA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7BC }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7BC }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7BC }};
        std::array<uint32_t, 1> const c4 = {{ 0x03C3 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03C3 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_083)
{
    // 1D7BD;1D7BD;1D7BD;03C4;03C4;
    // (𝞽; 𝞽; 𝞽; τ; τ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL TAU
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7BD }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7BD }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7BD }};
        std::array<uint32_t, 1> const c4 = {{ 0x03C4 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03C4 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_084)
{
    // 1D7BE;1D7BE;1D7BE;03C5;03C5;
    // (𝞾; 𝞾; 𝞾; υ; υ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL UPSILON
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7BE }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7BE }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7BE }};
        std::array<uint32_t, 1> const c4 = {{ 0x03C5 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03C5 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_085)
{
    // 1D7BF;1D7BF;1D7BF;03C6;03C6;
    // (𝞿; 𝞿; 𝞿; φ; φ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL PHI
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7BF }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7BF }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7BF }};
        std::array<uint32_t, 1> const c4 = {{ 0x03C6 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03C6 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_086)
{
    // 1D7C0;1D7C0;1D7C0;03C7;03C7;
    // (𝟀; 𝟀; 𝟀; χ; χ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL CHI
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7C0 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7C0 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7C0 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03C7 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03C7 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_087)
{
    // 1D7C1;1D7C1;1D7C1;03C8;03C8;
    // (𝟁; 𝟁; 𝟁; ψ; ψ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL PSI
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7C1 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7C1 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7C1 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03C8 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03C8 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_088)
{
    // 1D7C2;1D7C2;1D7C2;03C9;03C9;
    // (𝟂; 𝟂; 𝟂; ω; ω; ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL OMEGA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7C2 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7C2 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7C2 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03C9 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03C9 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_089)
{
    // 1D7C3;1D7C3;1D7C3;2202;2202;
    // (𝟃; 𝟃; 𝟃; ∂; ∂; ) MATHEMATICAL SANS-SERIF BOLD ITALIC PARTIAL DIFFERENTIAL
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7C3 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7C3 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7C3 }};
        std::array<uint32_t, 1> const c4 = {{ 0x2202 }};
        std::array<uint32_t, 1> const c5 = {{ 0x2202 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_090)
{
    // 1D7C4;1D7C4;1D7C4;03B5;03B5;
    // (𝟄; 𝟄; 𝟄; ε; ε; ) MATHEMATICAL SANS-SERIF BOLD ITALIC EPSILON SYMBOL
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7C4 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7C4 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7C4 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03B5 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03B5 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_091)
{
    // 1D7C5;1D7C5;1D7C5;03B8;03B8;
    // (𝟅; 𝟅; 𝟅; θ; θ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC THETA SYMBOL
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7C5 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7C5 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7C5 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03B8 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03B8 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_092)
{
    // 1D7C6;1D7C6;1D7C6;03BA;03BA;
    // (𝟆; 𝟆; 𝟆; κ; κ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC KAPPA SYMBOL
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7C6 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7C6 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7C6 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03BA }};
        std::array<uint32_t, 1> const c5 = {{ 0x03BA }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_093)
{
    // 1D7C7;1D7C7;1D7C7;03C6;03C6;
    // (𝟇; 𝟇; 𝟇; φ; φ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC PHI SYMBOL
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7C7 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7C7 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7C7 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03C6 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03C6 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_094)
{
    // 1D7C8;1D7C8;1D7C8;03C1;03C1;
    // (𝟈; 𝟈; 𝟈; ρ; ρ; ) MATHEMATICAL SANS-SERIF BOLD ITALIC RHO SYMBOL
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7C8 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7C8 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7C8 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03C1 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03C1 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_095)
{
    // 1D7C9;1D7C9;1D7C9;03C0;03C0;
    // (𝟉; 𝟉; 𝟉; π; π; ) MATHEMATICAL SANS-SERIF BOLD ITALIC PI SYMBOL
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7C9 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7C9 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7C9 }};
        std::array<uint32_t, 1> const c4 = {{ 0x03C0 }};
        std::array<uint32_t, 1> const c5 = {{ 0x03C0 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_096)
{
    // 1D7CA;1D7CA;1D7CA;03DC;03DC;
    // (𝟊; 𝟊; 𝟊; Ϝ; Ϝ; ) MATHEMATICAL BOLD CAPITAL DIGAMMA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7CA }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7CA }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7CA }};
        std::array<uint32_t, 1> const c4 = {{ 0x03DC }};
        std::array<uint32_t, 1> const c5 = {{ 0x03DC }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_097)
{
    // 1D7CB;1D7CB;1D7CB;03DD;03DD;
    // (𝟋; 𝟋; 𝟋; ϝ; ϝ; ) MATHEMATICAL BOLD SMALL DIGAMMA
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7CB }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7CB }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7CB }};
        std::array<uint32_t, 1> const c4 = {{ 0x03DD }};
        std::array<uint32_t, 1> const c5 = {{ 0x03DD }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_098)
{
    // 1D7CE;1D7CE;1D7CE;0030;0030;
    // (𝟎; 𝟎; 𝟎; 0; 0; ) MATHEMATICAL BOLD DIGIT ZERO
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7CE }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7CE }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7CE }};
        std::array<uint32_t, 1> const c4 = {{ 0x0030 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0030 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_099)
{
    // 1D7CF;1D7CF;1D7CF;0031;0031;
    // (𝟏; 𝟏; 𝟏; 1; 1; ) MATHEMATICAL BOLD DIGIT ONE
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7CF }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7CF }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7CF }};
        std::array<uint32_t, 1> const c4 = {{ 0x0031 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0031 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_100)
{
    // 1D7D0;1D7D0;1D7D0;0032;0032;
    // (𝟐; 𝟐; 𝟐; 2; 2; ) MATHEMATICAL BOLD DIGIT TWO
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7D0 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7D0 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7D0 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0032 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0032 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_101)
{
    // 1D7D1;1D7D1;1D7D1;0033;0033;
    // (𝟑; 𝟑; 𝟑; 3; 3; ) MATHEMATICAL BOLD DIGIT THREE
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7D1 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7D1 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7D1 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0033 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0033 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_102)
{
    // 1D7D2;1D7D2;1D7D2;0034;0034;
    // (𝟒; 𝟒; 𝟒; 4; 4; ) MATHEMATICAL BOLD DIGIT FOUR
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7D2 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7D2 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7D2 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0034 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0034 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_103)
{
    // 1D7D3;1D7D3;1D7D3;0035;0035;
    // (𝟓; 𝟓; 𝟓; 5; 5; ) MATHEMATICAL BOLD DIGIT FIVE
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7D3 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7D3 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7D3 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0035 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0035 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_104)
{
    // 1D7D4;1D7D4;1D7D4;0036;0036;
    // (𝟔; 𝟔; 𝟔; 6; 6; ) MATHEMATICAL BOLD DIGIT SIX
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7D4 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7D4 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7D4 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0036 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0036 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_105)
{
    // 1D7D5;1D7D5;1D7D5;0037;0037;
    // (𝟕; 𝟕; 𝟕; 7; 7; ) MATHEMATICAL BOLD DIGIT SEVEN
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7D5 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7D5 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7D5 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0037 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0037 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_106)
{
    // 1D7D6;1D7D6;1D7D6;0038;0038;
    // (𝟖; 𝟖; 𝟖; 8; 8; ) MATHEMATICAL BOLD DIGIT EIGHT
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7D6 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7D6 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7D6 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0038 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0038 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_107)
{
    // 1D7D7;1D7D7;1D7D7;0039;0039;
    // (𝟗; 𝟗; 𝟗; 9; 9; ) MATHEMATICAL BOLD DIGIT NINE
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7D7 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7D7 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7D7 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0039 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0039 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_108)
{
    // 1D7D8;1D7D8;1D7D8;0030;0030;
    // (𝟘; 𝟘; 𝟘; 0; 0; ) MATHEMATICAL DOUBLE-STRUCK DIGIT ZERO
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7D8 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7D8 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7D8 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0030 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0030 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_109)
{
    // 1D7D9;1D7D9;1D7D9;0031;0031;
    // (𝟙; 𝟙; 𝟙; 1; 1; ) MATHEMATICAL DOUBLE-STRUCK DIGIT ONE
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7D9 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7D9 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7D9 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0031 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0031 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_110)
{
    // 1D7DA;1D7DA;1D7DA;0032;0032;
    // (𝟚; 𝟚; 𝟚; 2; 2; ) MATHEMATICAL DOUBLE-STRUCK DIGIT TWO
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7DA }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7DA }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7DA }};
        std::array<uint32_t, 1> const c4 = {{ 0x0032 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0032 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_111)
{
    // 1D7DB;1D7DB;1D7DB;0033;0033;
    // (𝟛; 𝟛; 𝟛; 3; 3; ) MATHEMATICAL DOUBLE-STRUCK DIGIT THREE
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7DB }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7DB }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7DB }};
        std::array<uint32_t, 1> const c4 = {{ 0x0033 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0033 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_112)
{
    // 1D7DC;1D7DC;1D7DC;0034;0034;
    // (𝟜; 𝟜; 𝟜; 4; 4; ) MATHEMATICAL DOUBLE-STRUCK DIGIT FOUR
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7DC }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7DC }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7DC }};
        std::array<uint32_t, 1> const c4 = {{ 0x0034 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0034 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_113)
{
    // 1D7DD;1D7DD;1D7DD;0035;0035;
    // (𝟝; 𝟝; 𝟝; 5; 5; ) MATHEMATICAL DOUBLE-STRUCK DIGIT FIVE
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7DD }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7DD }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7DD }};
        std::array<uint32_t, 1> const c4 = {{ 0x0035 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0035 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_114)
{
    // 1D7DE;1D7DE;1D7DE;0036;0036;
    // (𝟞; 𝟞; 𝟞; 6; 6; ) MATHEMATICAL DOUBLE-STRUCK DIGIT SIX
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7DE }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7DE }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7DE }};
        std::array<uint32_t, 1> const c4 = {{ 0x0036 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0036 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_115)
{
    // 1D7DF;1D7DF;1D7DF;0037;0037;
    // (𝟟; 𝟟; 𝟟; 7; 7; ) MATHEMATICAL DOUBLE-STRUCK DIGIT SEVEN
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7DF }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7DF }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7DF }};
        std::array<uint32_t, 1> const c4 = {{ 0x0037 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0037 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_116)
{
    // 1D7E0;1D7E0;1D7E0;0038;0038;
    // (𝟠; 𝟠; 𝟠; 8; 8; ) MATHEMATICAL DOUBLE-STRUCK DIGIT EIGHT
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7E0 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7E0 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7E0 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0038 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0038 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_117)
{
    // 1D7E1;1D7E1;1D7E1;0039;0039;
    // (𝟡; 𝟡; 𝟡; 9; 9; ) MATHEMATICAL DOUBLE-STRUCK DIGIT NINE
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7E1 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7E1 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7E1 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0039 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0039 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_118)
{
    // 1D7E2;1D7E2;1D7E2;0030;0030;
    // (𝟢; 𝟢; 𝟢; 0; 0; ) MATHEMATICAL SANS-SERIF DIGIT ZERO
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7E2 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7E2 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7E2 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0030 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0030 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_119)
{
    // 1D7E3;1D7E3;1D7E3;0031;0031;
    // (𝟣; 𝟣; 𝟣; 1; 1; ) MATHEMATICAL SANS-SERIF DIGIT ONE
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7E3 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7E3 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7E3 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0031 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0031 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_120)
{
    // 1D7E4;1D7E4;1D7E4;0032;0032;
    // (𝟤; 𝟤; 𝟤; 2; 2; ) MATHEMATICAL SANS-SERIF DIGIT TWO
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7E4 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7E4 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7E4 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0032 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0032 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_121)
{
    // 1D7E5;1D7E5;1D7E5;0033;0033;
    // (𝟥; 𝟥; 𝟥; 3; 3; ) MATHEMATICAL SANS-SERIF DIGIT THREE
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7E5 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7E5 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7E5 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0033 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0033 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_122)
{
    // 1D7E6;1D7E6;1D7E6;0034;0034;
    // (𝟦; 𝟦; 𝟦; 4; 4; ) MATHEMATICAL SANS-SERIF DIGIT FOUR
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7E6 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7E6 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7E6 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0034 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0034 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_123)
{
    // 1D7E7;1D7E7;1D7E7;0035;0035;
    // (𝟧; 𝟧; 𝟧; 5; 5; ) MATHEMATICAL SANS-SERIF DIGIT FIVE
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7E7 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7E7 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7E7 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0035 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0035 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_124)
{
    // 1D7E8;1D7E8;1D7E8;0036;0036;
    // (𝟨; 𝟨; 𝟨; 6; 6; ) MATHEMATICAL SANS-SERIF DIGIT SIX
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7E8 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7E8 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7E8 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0036 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0036 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_125)
{
    // 1D7E9;1D7E9;1D7E9;0037;0037;
    // (𝟩; 𝟩; 𝟩; 7; 7; ) MATHEMATICAL SANS-SERIF DIGIT SEVEN
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7E9 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7E9 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7E9 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0037 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0037 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_126)
{
    // 1D7EA;1D7EA;1D7EA;0038;0038;
    // (𝟪; 𝟪; 𝟪; 8; 8; ) MATHEMATICAL SANS-SERIF DIGIT EIGHT
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7EA }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7EA }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7EA }};
        std::array<uint32_t, 1> const c4 = {{ 0x0038 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0038 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_127)
{
    // 1D7EB;1D7EB;1D7EB;0039;0039;
    // (𝟫; 𝟫; 𝟫; 9; 9; ) MATHEMATICAL SANS-SERIF DIGIT NINE
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7EB }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7EB }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7EB }};
        std::array<uint32_t, 1> const c4 = {{ 0x0039 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0039 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_128)
{
    // 1D7EC;1D7EC;1D7EC;0030;0030;
    // (𝟬; 𝟬; 𝟬; 0; 0; ) MATHEMATICAL SANS-SERIF BOLD DIGIT ZERO
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7EC }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7EC }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7EC }};
        std::array<uint32_t, 1> const c4 = {{ 0x0030 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0030 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_129)
{
    // 1D7ED;1D7ED;1D7ED;0031;0031;
    // (𝟭; 𝟭; 𝟭; 1; 1; ) MATHEMATICAL SANS-SERIF BOLD DIGIT ONE
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7ED }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7ED }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7ED }};
        std::array<uint32_t, 1> const c4 = {{ 0x0031 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0031 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_130)
{
    // 1D7EE;1D7EE;1D7EE;0032;0032;
    // (𝟮; 𝟮; 𝟮; 2; 2; ) MATHEMATICAL SANS-SERIF BOLD DIGIT TWO
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7EE }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7EE }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7EE }};
        std::array<uint32_t, 1> const c4 = {{ 0x0032 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0032 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_131)
{
    // 1D7EF;1D7EF;1D7EF;0033;0033;
    // (𝟯; 𝟯; 𝟯; 3; 3; ) MATHEMATICAL SANS-SERIF BOLD DIGIT THREE
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7EF }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7EF }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7EF }};
        std::array<uint32_t, 1> const c4 = {{ 0x0033 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0033 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_132)
{
    // 1D7F0;1D7F0;1D7F0;0034;0034;
    // (𝟰; 𝟰; 𝟰; 4; 4; ) MATHEMATICAL SANS-SERIF BOLD DIGIT FOUR
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7F0 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7F0 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7F0 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0034 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0034 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_133)
{
    // 1D7F1;1D7F1;1D7F1;0035;0035;
    // (𝟱; 𝟱; 𝟱; 5; 5; ) MATHEMATICAL SANS-SERIF BOLD DIGIT FIVE
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7F1 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7F1 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7F1 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0035 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0035 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_134)
{
    // 1D7F2;1D7F2;1D7F2;0036;0036;
    // (𝟲; 𝟲; 𝟲; 6; 6; ) MATHEMATICAL SANS-SERIF BOLD DIGIT SIX
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7F2 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7F2 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7F2 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0036 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0036 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_135)
{
    // 1D7F3;1D7F3;1D7F3;0037;0037;
    // (𝟳; 𝟳; 𝟳; 7; 7; ) MATHEMATICAL SANS-SERIF BOLD DIGIT SEVEN
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7F3 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7F3 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7F3 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0037 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0037 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_136)
{
    // 1D7F4;1D7F4;1D7F4;0038;0038;
    // (𝟴; 𝟴; 𝟴; 8; 8; ) MATHEMATICAL SANS-SERIF BOLD DIGIT EIGHT
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7F4 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7F4 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7F4 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0038 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0038 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_137)
{
    // 1D7F5;1D7F5;1D7F5;0039;0039;
    // (𝟵; 𝟵; 𝟵; 9; 9; ) MATHEMATICAL SANS-SERIF BOLD DIGIT NINE
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7F5 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7F5 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7F5 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0039 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0039 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_138)
{
    // 1D7F6;1D7F6;1D7F6;0030;0030;
    // (𝟶; 𝟶; 𝟶; 0; 0; ) MATHEMATICAL MONOSPACE DIGIT ZERO
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7F6 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7F6 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7F6 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0030 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0030 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_139)
{
    // 1D7F7;1D7F7;1D7F7;0031;0031;
    // (𝟷; 𝟷; 𝟷; 1; 1; ) MATHEMATICAL MONOSPACE DIGIT ONE
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7F7 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7F7 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7F7 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0031 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0031 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_140)
{
    // 1D7F8;1D7F8;1D7F8;0032;0032;
    // (𝟸; 𝟸; 𝟸; 2; 2; ) MATHEMATICAL MONOSPACE DIGIT TWO
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7F8 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7F8 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7F8 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0032 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0032 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_141)
{
    // 1D7F9;1D7F9;1D7F9;0033;0033;
    // (𝟹; 𝟹; 𝟹; 3; 3; ) MATHEMATICAL MONOSPACE DIGIT THREE
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7F9 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7F9 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7F9 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0033 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0033 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_142)
{
    // 1D7FA;1D7FA;1D7FA;0034;0034;
    // (𝟺; 𝟺; 𝟺; 4; 4; ) MATHEMATICAL MONOSPACE DIGIT FOUR
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7FA }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7FA }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7FA }};
        std::array<uint32_t, 1> const c4 = {{ 0x0034 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0034 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_143)
{
    // 1D7FB;1D7FB;1D7FB;0035;0035;
    // (𝟻; 𝟻; 𝟻; 5; 5; ) MATHEMATICAL MONOSPACE DIGIT FIVE
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7FB }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7FB }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7FB }};
        std::array<uint32_t, 1> const c4 = {{ 0x0035 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0035 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_144)
{
    // 1D7FC;1D7FC;1D7FC;0036;0036;
    // (𝟼; 𝟼; 𝟼; 6; 6; ) MATHEMATICAL MONOSPACE DIGIT SIX
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7FC }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7FC }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7FC }};
        std::array<uint32_t, 1> const c4 = {{ 0x0036 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0036 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_145)
{
    // 1D7FD;1D7FD;1D7FD;0037;0037;
    // (𝟽; 𝟽; 𝟽; 7; 7; ) MATHEMATICAL MONOSPACE DIGIT SEVEN
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7FD }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7FD }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7FD }};
        std::array<uint32_t, 1> const c4 = {{ 0x0037 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0037 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_146)
{
    // 1D7FE;1D7FE;1D7FE;0038;0038;
    // (𝟾; 𝟾; 𝟾; 8; 8; ) MATHEMATICAL MONOSPACE DIGIT EIGHT
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7FE }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7FE }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7FE }};
        std::array<uint32_t, 1> const c4 = {{ 0x0038 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0038 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_147)
{
    // 1D7FF;1D7FF;1D7FF;0039;0039;
    // (𝟿; 𝟿; 𝟿; 9; 9; ) MATHEMATICAL MONOSPACE DIGIT NINE
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1D7FF }};
        std::array<uint32_t, 1> const c2 = {{ 0x1D7FF }};
        std::array<uint32_t, 1> const c3 = {{ 0x1D7FF }};
        std::array<uint32_t, 1> const c4 = {{ 0x0039 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0039 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_148)
{
    // 1EE00;1EE00;1EE00;0627;0627;
    // (𞸀; 𞸀; 𞸀; ا; ا; ) ARABIC MATHEMATICAL ALEF
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE00 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE00 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE00 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0627 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0627 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_149)
{
    // 1EE01;1EE01;1EE01;0628;0628;
    // (𞸁; 𞸁; 𞸁; ب; ب; ) ARABIC MATHEMATICAL BEH
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE01 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE01 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE01 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0628 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0628 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_150)
{
    // 1EE02;1EE02;1EE02;062C;062C;
    // (𞸂; 𞸂; 𞸂; ج; ج; ) ARABIC MATHEMATICAL JEEM
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE02 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE02 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE02 }};
        std::array<uint32_t, 1> const c4 = {{ 0x062C }};
        std::array<uint32_t, 1> const c5 = {{ 0x062C }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_151)
{
    // 1EE03;1EE03;1EE03;062F;062F;
    // (𞸃; 𞸃; 𞸃; د; د; ) ARABIC MATHEMATICAL DAL
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE03 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE03 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE03 }};
        std::array<uint32_t, 1> const c4 = {{ 0x062F }};
        std::array<uint32_t, 1> const c5 = {{ 0x062F }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_152)
{
    // 1EE05;1EE05;1EE05;0648;0648;
    // (𞸅; 𞸅; 𞸅; و; و; ) ARABIC MATHEMATICAL WAW
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE05 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE05 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE05 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0648 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0648 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_153)
{
    // 1EE06;1EE06;1EE06;0632;0632;
    // (𞸆; 𞸆; 𞸆; ز; ز; ) ARABIC MATHEMATICAL ZAIN
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE06 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE06 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE06 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0632 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0632 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_154)
{
    // 1EE07;1EE07;1EE07;062D;062D;
    // (𞸇; 𞸇; 𞸇; ح; ح; ) ARABIC MATHEMATICAL HAH
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE07 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE07 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE07 }};
        std::array<uint32_t, 1> const c4 = {{ 0x062D }};
        std::array<uint32_t, 1> const c5 = {{ 0x062D }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_155)
{
    // 1EE08;1EE08;1EE08;0637;0637;
    // (𞸈; 𞸈; 𞸈; ط; ط; ) ARABIC MATHEMATICAL TAH
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE08 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE08 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE08 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0637 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0637 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_156)
{
    // 1EE09;1EE09;1EE09;064A;064A;
    // (𞸉; 𞸉; 𞸉; ي; ي; ) ARABIC MATHEMATICAL YEH
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE09 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE09 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE09 }};
        std::array<uint32_t, 1> const c4 = {{ 0x064A }};
        std::array<uint32_t, 1> const c5 = {{ 0x064A }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_157)
{
    // 1EE0A;1EE0A;1EE0A;0643;0643;
    // (𞸊; 𞸊; 𞸊; ك; ك; ) ARABIC MATHEMATICAL KAF
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE0A }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE0A }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE0A }};
        std::array<uint32_t, 1> const c4 = {{ 0x0643 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0643 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_158)
{
    // 1EE0B;1EE0B;1EE0B;0644;0644;
    // (𞸋; 𞸋; 𞸋; ل; ل; ) ARABIC MATHEMATICAL LAM
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE0B }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE0B }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE0B }};
        std::array<uint32_t, 1> const c4 = {{ 0x0644 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0644 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_159)
{
    // 1EE0C;1EE0C;1EE0C;0645;0645;
    // (𞸌; 𞸌; 𞸌; م; م; ) ARABIC MATHEMATICAL MEEM
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE0C }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE0C }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE0C }};
        std::array<uint32_t, 1> const c4 = {{ 0x0645 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0645 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_160)
{
    // 1EE0D;1EE0D;1EE0D;0646;0646;
    // (𞸍; 𞸍; 𞸍; ن; ن; ) ARABIC MATHEMATICAL NOON
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE0D }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE0D }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE0D }};
        std::array<uint32_t, 1> const c4 = {{ 0x0646 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0646 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_161)
{
    // 1EE0E;1EE0E;1EE0E;0633;0633;
    // (𞸎; 𞸎; 𞸎; س; س; ) ARABIC MATHEMATICAL SEEN
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE0E }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE0E }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE0E }};
        std::array<uint32_t, 1> const c4 = {{ 0x0633 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0633 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_162)
{
    // 1EE0F;1EE0F;1EE0F;0639;0639;
    // (𞸏; 𞸏; 𞸏; ع; ع; ) ARABIC MATHEMATICAL AIN
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE0F }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE0F }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE0F }};
        std::array<uint32_t, 1> const c4 = {{ 0x0639 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0639 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_163)
{
    // 1EE10;1EE10;1EE10;0641;0641;
    // (𞸐; 𞸐; 𞸐; ف; ف; ) ARABIC MATHEMATICAL FEH
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE10 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE10 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE10 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0641 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0641 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_164)
{
    // 1EE11;1EE11;1EE11;0635;0635;
    // (𞸑; 𞸑; 𞸑; ص; ص; ) ARABIC MATHEMATICAL SAD
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE11 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE11 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE11 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0635 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0635 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_165)
{
    // 1EE12;1EE12;1EE12;0642;0642;
    // (𞸒; 𞸒; 𞸒; ق; ق; ) ARABIC MATHEMATICAL QAF
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE12 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE12 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE12 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0642 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0642 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_166)
{
    // 1EE13;1EE13;1EE13;0631;0631;
    // (𞸓; 𞸓; 𞸓; ر; ر; ) ARABIC MATHEMATICAL REH
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE13 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE13 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE13 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0631 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0631 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_167)
{
    // 1EE14;1EE14;1EE14;0634;0634;
    // (𞸔; 𞸔; 𞸔; ش; ش; ) ARABIC MATHEMATICAL SHEEN
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE14 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE14 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE14 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0634 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0634 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_168)
{
    // 1EE15;1EE15;1EE15;062A;062A;
    // (𞸕; 𞸕; 𞸕; ت; ت; ) ARABIC MATHEMATICAL TEH
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE15 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE15 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE15 }};
        std::array<uint32_t, 1> const c4 = {{ 0x062A }};
        std::array<uint32_t, 1> const c5 = {{ 0x062A }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_169)
{
    // 1EE16;1EE16;1EE16;062B;062B;
    // (𞸖; 𞸖; 𞸖; ث; ث; ) ARABIC MATHEMATICAL THEH
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE16 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE16 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE16 }};
        std::array<uint32_t, 1> const c4 = {{ 0x062B }};
        std::array<uint32_t, 1> const c5 = {{ 0x062B }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_170)
{
    // 1EE17;1EE17;1EE17;062E;062E;
    // (𞸗; 𞸗; 𞸗; خ; خ; ) ARABIC MATHEMATICAL KHAH
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE17 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE17 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE17 }};
        std::array<uint32_t, 1> const c4 = {{ 0x062E }};
        std::array<uint32_t, 1> const c5 = {{ 0x062E }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_171)
{
    // 1EE18;1EE18;1EE18;0630;0630;
    // (𞸘; 𞸘; 𞸘; ذ; ذ; ) ARABIC MATHEMATICAL THAL
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE18 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE18 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE18 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0630 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0630 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_172)
{
    // 1EE19;1EE19;1EE19;0636;0636;
    // (𞸙; 𞸙; 𞸙; ض; ض; ) ARABIC MATHEMATICAL DAD
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE19 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE19 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE19 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0636 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0636 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_173)
{
    // 1EE1A;1EE1A;1EE1A;0638;0638;
    // (𞸚; 𞸚; 𞸚; ظ; ظ; ) ARABIC MATHEMATICAL ZAH
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE1A }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE1A }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE1A }};
        std::array<uint32_t, 1> const c4 = {{ 0x0638 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0638 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_174)
{
    // 1EE1B;1EE1B;1EE1B;063A;063A;
    // (𞸛; 𞸛; 𞸛; غ; غ; ) ARABIC MATHEMATICAL GHAIN
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE1B }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE1B }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE1B }};
        std::array<uint32_t, 1> const c4 = {{ 0x063A }};
        std::array<uint32_t, 1> const c5 = {{ 0x063A }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_175)
{
    // 1EE1C;1EE1C;1EE1C;066E;066E;
    // (𞸜; 𞸜; 𞸜; ٮ; ٮ; ) ARABIC MATHEMATICAL DOTLESS BEH
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE1C }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE1C }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE1C }};
        std::array<uint32_t, 1> const c4 = {{ 0x066E }};
        std::array<uint32_t, 1> const c5 = {{ 0x066E }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_176)
{
    // 1EE1D;1EE1D;1EE1D;06BA;06BA;
    // (𞸝; 𞸝; 𞸝; ں; ں; ) ARABIC MATHEMATICAL DOTLESS NOON
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE1D }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE1D }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE1D }};
        std::array<uint32_t, 1> const c4 = {{ 0x06BA }};
        std::array<uint32_t, 1> const c5 = {{ 0x06BA }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_177)
{
    // 1EE1E;1EE1E;1EE1E;06A1;06A1;
    // (𞸞; 𞸞; 𞸞; ڡ; ڡ; ) ARABIC MATHEMATICAL DOTLESS FEH
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE1E }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE1E }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE1E }};
        std::array<uint32_t, 1> const c4 = {{ 0x06A1 }};
        std::array<uint32_t, 1> const c5 = {{ 0x06A1 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_178)
{
    // 1EE1F;1EE1F;1EE1F;066F;066F;
    // (𞸟; 𞸟; 𞸟; ٯ; ٯ; ) ARABIC MATHEMATICAL DOTLESS QAF
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE1F }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE1F }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE1F }};
        std::array<uint32_t, 1> const c4 = {{ 0x066F }};
        std::array<uint32_t, 1> const c5 = {{ 0x066F }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_179)
{
    // 1EE21;1EE21;1EE21;0628;0628;
    // (𞸡; 𞸡; 𞸡; ب; ب; ) ARABIC MATHEMATICAL INITIAL BEH
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE21 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE21 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE21 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0628 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0628 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_180)
{
    // 1EE22;1EE22;1EE22;062C;062C;
    // (𞸢; 𞸢; 𞸢; ج; ج; ) ARABIC MATHEMATICAL INITIAL JEEM
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE22 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE22 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE22 }};
        std::array<uint32_t, 1> const c4 = {{ 0x062C }};
        std::array<uint32_t, 1> const c5 = {{ 0x062C }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_181)
{
    // 1EE24;1EE24;1EE24;0647;0647;
    // (𞸤; 𞸤; 𞸤; ه; ه; ) ARABIC MATHEMATICAL INITIAL HEH
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE24 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE24 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE24 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0647 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0647 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_182)
{
    // 1EE27;1EE27;1EE27;062D;062D;
    // (𞸧; 𞸧; 𞸧; ح; ح; ) ARABIC MATHEMATICAL INITIAL HAH
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE27 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE27 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE27 }};
        std::array<uint32_t, 1> const c4 = {{ 0x062D }};
        std::array<uint32_t, 1> const c5 = {{ 0x062D }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_183)
{
    // 1EE29;1EE29;1EE29;064A;064A;
    // (𞸩; 𞸩; 𞸩; ي; ي; ) ARABIC MATHEMATICAL INITIAL YEH
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE29 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE29 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE29 }};
        std::array<uint32_t, 1> const c4 = {{ 0x064A }};
        std::array<uint32_t, 1> const c5 = {{ 0x064A }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_184)
{
    // 1EE2A;1EE2A;1EE2A;0643;0643;
    // (𞸪; 𞸪; 𞸪; ك; ك; ) ARABIC MATHEMATICAL INITIAL KAF
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE2A }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE2A }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE2A }};
        std::array<uint32_t, 1> const c4 = {{ 0x0643 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0643 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_185)
{
    // 1EE2B;1EE2B;1EE2B;0644;0644;
    // (𞸫; 𞸫; 𞸫; ل; ل; ) ARABIC MATHEMATICAL INITIAL LAM
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE2B }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE2B }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE2B }};
        std::array<uint32_t, 1> const c4 = {{ 0x0644 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0644 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_186)
{
    // 1EE2C;1EE2C;1EE2C;0645;0645;
    // (𞸬; 𞸬; 𞸬; م; م; ) ARABIC MATHEMATICAL INITIAL MEEM
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE2C }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE2C }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE2C }};
        std::array<uint32_t, 1> const c4 = {{ 0x0645 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0645 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_187)
{
    // 1EE2D;1EE2D;1EE2D;0646;0646;
    // (𞸭; 𞸭; 𞸭; ن; ن; ) ARABIC MATHEMATICAL INITIAL NOON
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE2D }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE2D }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE2D }};
        std::array<uint32_t, 1> const c4 = {{ 0x0646 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0646 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_188)
{
    // 1EE2E;1EE2E;1EE2E;0633;0633;
    // (𞸮; 𞸮; 𞸮; س; س; ) ARABIC MATHEMATICAL INITIAL SEEN
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE2E }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE2E }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE2E }};
        std::array<uint32_t, 1> const c4 = {{ 0x0633 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0633 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_189)
{
    // 1EE2F;1EE2F;1EE2F;0639;0639;
    // (𞸯; 𞸯; 𞸯; ع; ع; ) ARABIC MATHEMATICAL INITIAL AIN
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE2F }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE2F }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE2F }};
        std::array<uint32_t, 1> const c4 = {{ 0x0639 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0639 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_190)
{
    // 1EE30;1EE30;1EE30;0641;0641;
    // (𞸰; 𞸰; 𞸰; ف; ف; ) ARABIC MATHEMATICAL INITIAL FEH
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE30 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE30 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE30 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0641 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0641 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_191)
{
    // 1EE31;1EE31;1EE31;0635;0635;
    // (𞸱; 𞸱; 𞸱; ص; ص; ) ARABIC MATHEMATICAL INITIAL SAD
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE31 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE31 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE31 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0635 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0635 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_192)
{
    // 1EE32;1EE32;1EE32;0642;0642;
    // (𞸲; 𞸲; 𞸲; ق; ق; ) ARABIC MATHEMATICAL INITIAL QAF
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE32 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE32 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE32 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0642 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0642 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_193)
{
    // 1EE34;1EE34;1EE34;0634;0634;
    // (𞸴; 𞸴; 𞸴; ش; ش; ) ARABIC MATHEMATICAL INITIAL SHEEN
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE34 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE34 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE34 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0634 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0634 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_194)
{
    // 1EE35;1EE35;1EE35;062A;062A;
    // (𞸵; 𞸵; 𞸵; ت; ت; ) ARABIC MATHEMATICAL INITIAL TEH
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE35 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE35 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE35 }};
        std::array<uint32_t, 1> const c4 = {{ 0x062A }};
        std::array<uint32_t, 1> const c5 = {{ 0x062A }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_195)
{
    // 1EE36;1EE36;1EE36;062B;062B;
    // (𞸶; 𞸶; 𞸶; ث; ث; ) ARABIC MATHEMATICAL INITIAL THEH
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE36 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE36 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE36 }};
        std::array<uint32_t, 1> const c4 = {{ 0x062B }};
        std::array<uint32_t, 1> const c5 = {{ 0x062B }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_196)
{
    // 1EE37;1EE37;1EE37;062E;062E;
    // (𞸷; 𞸷; 𞸷; خ; خ; ) ARABIC MATHEMATICAL INITIAL KHAH
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE37 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE37 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE37 }};
        std::array<uint32_t, 1> const c4 = {{ 0x062E }};
        std::array<uint32_t, 1> const c5 = {{ 0x062E }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_197)
{
    // 1EE39;1EE39;1EE39;0636;0636;
    // (𞸹; 𞸹; 𞸹; ض; ض; ) ARABIC MATHEMATICAL INITIAL DAD
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE39 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE39 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE39 }};
        std::array<uint32_t, 1> const c4 = {{ 0x0636 }};
        std::array<uint32_t, 1> const c5 = {{ 0x0636 }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_198)
{
    // 1EE3B;1EE3B;1EE3B;063A;063A;
    // (𞸻; 𞸻; 𞸻; غ; غ; ) ARABIC MATHEMATICAL INITIAL GHAIN
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE3B }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE3B }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE3B }};
        std::array<uint32_t, 1> const c4 = {{ 0x063A }};
        std::array<uint32_t, 1> const c5 = {{ 0x063A }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

TEST(normalization, nfkd_080_199)
{
    // 1EE42;1EE42;1EE42;062C;062C;
    // (𞹂; 𞹂; 𞹂; ج; ج; ) ARABIC MATHEMATICAL TAILED JEEM
    {
        std::array<uint32_t, 1> const c1 = {{ 0x1EE42 }};
        std::array<uint32_t, 1> const c2 = {{ 0x1EE42 }};
        std::array<uint32_t, 1> const c3 = {{ 0x1EE42 }};
        std::array<uint32_t, 1> const c4 = {{ 0x062C }};
        std::array<uint32_t, 1> const c5 = {{ 0x062C }};

        EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));

        EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
        EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));

        EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
        EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));

        {
            boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
            boost::text::normalize_to_nfkd(str);
            auto const r = boost::text::as_utf32(str);
            EXPECT_EQ(std::distance(r.begin(), r.end()), (std::ptrdiff_t)c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : r) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}

max_stars_repo_name: eightysquirrels/text

max_issues_repo_name: eightysquirrels/text

max_forks_repo_name: eightysquirrels/text