diff --git a/CMakeLists.txt b/CMakeLists.txt
index 527425ba24..566088ed1b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -13,7 +13,7 @@ target_link_libraries(${PROJECT_NAME} INTERFACE Boost::headers fmt::fmt)
 add_library(${PROJECT_NAME}::${PROJECT_NAME} ALIAS ${PROJECT_NAME})
 
 # llama IDE target to make source browsable/editable in IDEs
-file(GLOB_RECURSE llamaSources "${CMAKE_CURRENT_SOURCE_DIR}/include/**")
+file(GLOB_RECURSE llamaSources "${CMAKE_CURRENT_SOURCE_DIR}/include/llama/**")
 add_custom_target("llamaIde" SOURCES ${llamaSources})
 source_group(TREE "${CMAKE_CURRENT_LIST_DIR}/include/llama" FILES ${llamaSources})
 
diff --git a/examples/nbody/nbody.cpp b/examples/nbody/nbody.cpp
index e4fb515e1f..c18b61bac2 100644
--- a/examples/nbody/nbody.cpp
+++ b/examples/nbody/nbody.cpp
@@ -34,45 +34,86 @@ constexpr auto L1D_SIZE = 32 * 1024;
 constexpr auto L2D_SIZE = 512 * 1024;
 
 using namespace std::string_literals;
+using namespace llama::literals;
 
 namespace usellama
 {
-    // clang-format off
-    namespace tag
+    struct Vec
     {
-        struct Pos{};
-        struct Vel{};
-        struct X{};
-        struct Y{};
-        struct Z{};
-        struct Mass{};
-    }
+        FP x;
+        FP y;
+        FP z;
+
+        auto operator*=(FP s) -> Vec&
+        {
+            x *= s;
+            y *= s;
+            z *= s;
+            return *this;
+        }
+
+        auto operator*=(Vec v) -> Vec&
+        {
+            x *= v.x;
+            y *= v.y;
+            z *= v.z;
+            return *this;
+        }
 
-    using Particle = llama::DS<
-        llama::DE<tag::Pos, llama::DS<
-            llama::DE<tag::X, FP>,
-            llama::DE<tag::Y, FP>,
-            llama::DE<tag::Z, FP>
-        >>,
-        llama::DE<tag::Vel, llama::DS<
-            llama::DE<tag::X, FP>,
-            llama::DE<tag::Y, FP>,
-            llama::DE<tag::Z, FP>
-        >>,
-        llama::DE<tag::Mass, FP>
-    >;
-    // clang-format on
+        auto operator+=(Vec v) -> Vec&
+        {
+            x += v.x;
+            y += v.y;
+            z += v.z;
+            return *this;
+        }
+
+        auto operator-=(Vec v) -> Vec&
+        {
+            x -= v.x;
+            y -= v.y;
+            z -= v.z;
+            return *this;
+        }
+
+        friend auto operator+(Vec a, Vec b) -> Vec
+        {
+            return a += b;
+        }
+
+        friend auto operator-(Vec a, Vec b) -> Vec
+        {
+            return a -= b;
+        }
+
+        friend auto operator*(Vec a, FP s) -> Vec
+        {
+            return a *= s;
+        }
+
+        friend auto operator*(Vec a, Vec b) -> Vec
+        {
+            return a *= b;
+        }
+    };
+
+    struct Particle
+    {
+        Vec pos;
+        Vec vel;
+        FP mass;
+    };
 
     template <typename VirtualParticleI, typename VirtualParticleJ>
     LLAMA_FN_HOST_ACC_INLINE void pPInteraction(VirtualParticleI&& pi, VirtualParticleJ pj)
     {
-        auto dist = pi(tag::Pos{}) - pj(tag::Pos{});
+        auto dist = pi->pos - pj->pos;
         dist *= dist;
-        const FP distSqr = EPS2 + dist(tag::X{}) + dist(tag::Y{}) + dist(tag::Z{});
+        const FP distSqr = EPS2 + dist.x + dist.y + dist.z;
         const FP distSixth = distSqr * distSqr * distSqr;
         const FP invDistCube = 1.0f / std::sqrt(distSixth);
-        const FP sts = pj(tag::Mass{}) * invDistCube * TIMESTEP;
-        pi(tag::Vel{}) += dist * sts;
+        const FP sts = pj->mass * invDistCube * TIMESTEP;
+        pi(1_DC) = pi->vel + dist * sts;
     }
 
     template <bool UseAccumulator, typename View>
@@ -102,7 +143,7 @@ namespace usellama
     {
         LLAMA_INDEPENDENT_DATA
         for (std::size_t i = 0; i < PROBLEM_SIZE; i++)
-            particles(i)(tag::Pos{}) += particles(i)(tag::Vel{}) * TIMESTEP;
+            particles(i)(0_DC) = particles(i)->pos + particles(i)->vel * TIMESTEP;
     }
 
     template <int Mapping, bool UseAccumulator, std::size_t AoSoALanes = 8 /*AVX2*/>
@@ -162,14 +203,15 @@ namespace usellama
         std::normal_distribution<FP> dist(FP(0), FP(1));
         for (std::size_t i = 0; i < PROBLEM_SIZE; ++i)
         {
-            auto p = particles(i);
-            p(tag::Pos{}, tag::X{}) = dist(engine);
-            p(tag::Pos{}, tag::Y{}) = dist(engine);
-            p(tag::Pos{}, tag::Z{}) = dist(engine);
-            p(tag::Vel{}, tag::X{}) = dist(engine) / FP(10);
-            p(tag::Vel{}, tag::Y{}) = dist(engine) / FP(10);
-            p(tag::Vel{}, tag::Z{}) = dist(engine) / FP(10);
-            p(tag::Mass{}) = dist(engine) / FP(100);
+            Particle p;
+            p.pos.x = dist(engine);
+            p.pos.y = dist(engine);
+            p.pos.z = dist(engine);
+            p.vel.x = dist(engine) / FP(10);
+            p.vel.y = dist(engine) / FP(10);
+            p.vel.z = dist(engine) / FP(10);
+            p.mass = dist(engine) / FP(100);
+            particles(i) = p;
         }
         watch.printAndReset("init");
 
diff --git a/include/boost/pfr.hpp b/include/boost/pfr.hpp
new file mode 100644
index 0000000000..4c425cac54
--- /dev/null
+++ b/include/boost/pfr.hpp
@@ -0,0 +1,21 @@
+// Copyright (c) 2016-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_HPP
+#define BOOST_PFR_HPP
+
+/// \file boost/pfr.hpp
+/// Includes all the Boost.PFR headers
+
+#include <boost/pfr/core.hpp>
+#include <boost/pfr/functions_for.hpp>
+#include <boost/pfr/functors.hpp>
+#include <boost/pfr/io.hpp>
+#include <boost/pfr/io_fields.hpp>
+#include <boost/pfr/ops.hpp>
+#include <boost/pfr/ops_fields.hpp>
+#include <boost/pfr/tuple_size.hpp>
+
+#endif // BOOST_PFR_HPP
diff --git a/include/boost/pfr/core.hpp b/include/boost/pfr/core.hpp
new file mode 100644
index 0000000000..7022733a3f
--- /dev/null
+++ b/include/boost/pfr/core.hpp
@@ -0,0 +1,226 @@
+// Copyright (c) 2016-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_CORE_HPP
+#define BOOST_PFR_CORE_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <boost/pfr/detail/core.hpp>
+
+#include <boost/pfr/detail/sequence_tuple.hpp>
+#include <boost/pfr/detail/stdtuple.hpp>
+#include <boost/pfr/detail/for_each_field_impl.hpp>
+#include <boost/pfr/detail/make_integer_sequence.hpp>
+#include <boost/pfr/detail/tie_from_structure_tuple.hpp>
+
+#include <type_traits>
+#include <utility>      // metaprogramming stuff
+
+#include <boost/pfr/tuple_size.hpp>
+
+/// \file boost/pfr/core.hpp
+/// Contains all the basic tuple-like interfaces \forcedlink{get}, \forcedlink{tuple_size}, \forcedlink{tuple_element_t}, and others.
+///
+/// \b Synopsis:
+
+namespace boost { namespace pfr {
+
+/// \brief Returns reference or const reference to a field with index `I` in \aggregate `val`.
+///
+/// \b Example:
+/// \code
+///     struct my_struct { int i, short s; };
+///     my_struct s {10, 11};
+///     assert(boost::pfr::get<0>(s) == 10);
+///     boost::pfr::get<1>(s) = 0;
+/// \endcode
+template <std::size_t I, class T>
+constexpr decltype(auto) get(const T& val) noexcept {
+    return detail::sequence_tuple::get<I>( detail::tie_as_tuple(val) );
+}
+
+
+/// \overload get
+template <std::size_t I, class T>
+constexpr decltype(auto) get(T& val
+#if !BOOST_PFR_USE_CPP17
+    , std::enable_if_t<std::is_assignable<T, T>::value>* = nullptr
+#endif
+) noexcept {
+    return detail::sequence_tuple::get<I>( detail::tie_as_tuple(val) );
+}
+
+#if !BOOST_PFR_USE_CPP17
+/// \overload get
+template <std::size_t I, class T>
+constexpr auto get(T&, std::enable_if_t<!std::is_assignable<T, T>::value>* = nullptr) noexcept {
+    static_assert(sizeof(T) && false, "====================> Boost.PFR: Calling boost::pfr::get on non const non assignable type is allowed only in C++17");
+    return 0;
+}
+#endif
+
+
+/// \overload get
+template <std::size_t I, class T>
+constexpr auto get(T&& val, std::enable_if_t< std::is_rvalue_reference<T&&>::value>* = 0) noexcept {
+    return std::move(detail::sequence_tuple::get<I>( detail::tie_as_tuple(val) ));
+}
+
+
+/// \brief `tuple_element` has a member typedef `type` that returns the type of a field with index I in \aggregate T.
+///
+/// \b Example:
+/// \code
+///     std::vector< boost::pfr::tuple_element<0, my_structure>::type > v;
+/// \endcode
+template <std::size_t I, class T>
+using tuple_element = detail::sequence_tuple::tuple_element<I, decltype( ::boost::pfr::detail::tie_as_tuple(std::declval<T&>()) ) >;
+
+
+/// \brief Type of a field with index `I` in \aggregate `T`.
+///
+/// \b Example:
+/// \code
+///     std::vector< boost::pfr::tuple_element_t<0, my_structure> > v;
+/// \endcode
+template <std::size_t I, class T>
+using tuple_element_t = typename tuple_element<I, T>::type;
+
+
+/// \brief Creates a `std::tuple` from fields of an \aggregate `val`.
+///
+/// \b Example:
+/// \code
+///     struct my_struct { int i, short s; };
+///     my_struct s {10, 11};
+///     std::tuple<int, short> t = make_tuple(s);
+///     assert(get<0>(t) == 10);
+/// \endcode
+template <class T>
+constexpr auto structure_to_tuple(const T& val) noexcept {
+    return detail::make_stdtuple_from_tietuple(
+        detail::tie_as_tuple(val),
+        detail::make_index_sequence< tuple_size_v<T> >()
+    );
+}
+
+
+/// \brief std::tie` like function that ties fields of a structure.
+///
+/// \returns a `std::tuple` with lvalue and const lvalue references to fields of an \aggregate `val`.
+///
+/// \b Example:
+/// \code
+///     void foo(const int&, const short&);
+///     struct my_struct { int i, short s; };
+///
+///     const my_struct const_s{1, 2};
+///     std::apply(foo, structure_tie(const_s));
+///
+///     my_struct s;
+///     structure_tie(s) = std::tuple<int, short>{10, 11};
+///     assert(s.s == 11);
+/// \endcode
+template <class T>
+constexpr auto structure_tie(const T& val) noexcept {
+    return detail::make_conststdtiedtuple_from_tietuple(
+        detail::tie_as_tuple(const_cast<T&>(val)),
+        detail::make_index_sequence< tuple_size_v<T> >()
+    );
+}
+
+
+/// \overload structure_tie
+template <class T>
+constexpr auto structure_tie(T& val
+#if !BOOST_PFR_USE_CPP17
+    , std::enable_if_t<std::is_assignable<T, T>::value>* = nullptr
+#endif
+) noexcept {
+    return detail::make_stdtiedtuple_from_tietuple(
+        detail::tie_as_tuple(val),
+        detail::make_index_sequence< tuple_size_v<T> >()
+    );
+}
+
+#if !BOOST_PFR_USE_CPP17
+/// \overload structure_tie
+template <class T>
+constexpr auto structure_tie(T&, std::enable_if_t<!std::is_assignable<T, T>::value>* = nullptr) noexcept {
+    static_assert(sizeof(T) && false, "====================> Boost.PFR: Calling boost::pfr::structure_tie on non const non assignable type is allowed only in C++17");
+    return 0;
+}
+#endif
+
+
+/// \overload structure_tie
+template <class T>
+constexpr auto structure_tie(T&&, std::enable_if_t< std::is_rvalue_reference<T&&>::value>* = 0) noexcept {
+    static_assert(sizeof(T) && false, "====================> Boost.PFR: Calling boost::pfr::structure_tie on rvalue references is forbidden");
+    return 0;
+}
+
+/// Calls `func` for each field of a `value`.
+///
+/// \param func must have one of the following signatures:
+///     * any_return_type func(U&& field)                // field of value is perfect forwarded to function
+///     * any_return_type func(U&& field, std::size_t i)
+///     * any_return_type func(U&& value, I i)           // Here I is an `std::integral_constant<size_t, field_index>`
+///
+/// \param value To each field of this variable will be the `func` applied.
+///
+/// \b Example:
+/// \code
+///     struct my_struct { int i, short s; };
+///     int sum = 0;
+///     for_each_field(my_struct{20, 22}, [&sum](const auto& field) { sum += field; });
+///     assert(sum == 42);
+/// \endcode
+template <class T, class F>
+void for_each_field(T&& value, F&& func) {
+    constexpr std::size_t fields_count_val = boost::pfr::detail::fields_count<std::remove_reference_t<T>>();
+
+    ::boost::pfr::detail::for_each_field_dispatcher(
+        value,
+        [f = std::forward<F>(func)](auto&& t) mutable {
+            // MSVC related workaround. Its lambdas do not capture constexprs.
+            constexpr std::size_t fields_count_val_in_lambda
+                = boost::pfr::detail::fields_count<std::remove_reference_t<T>>();
+
+            ::boost::pfr::detail::for_each_field_impl(
+                t,
+                std::forward<F>(f),
+                detail::make_index_sequence<fields_count_val_in_lambda>{},
+                std::is_rvalue_reference<T&&>{}
+            );
+        },
+        detail::make_index_sequence<fields_count_val>{}
+    );
+}
+
+/// \brief std::tie-like function that allows assigning to tied values from aggregates.
+///
+/// \returns an object with lvalue references to `args...`; on assignment of an \aggregate value to that
+/// object each field of an aggregate is assigned to the corresponding `args...` reference.
+///
+/// \b Example:
+/// \code
+///     auto f() {
+///       struct { struct { int x, y } p; short s; } res { { 4, 5 }, 6 };
+///       return res;
+///     }
+///     auto [p, s] = f();
+///     tie_from_structure(p, s) = f();
+/// \endcode
+template <typename... Elements>
+constexpr detail::tie_from_structure_tuple<Elements...> tie_from_structure(Elements&... args) noexcept {
+    return detail::tie_from_structure_tuple<Elements...>(args...);
+}
+
+}} // namespace boost::pfr
+
+#endif // BOOST_PFR_CORE_HPP
diff --git a/include/boost/pfr/detail/cast_to_layout_compatible.hpp b/include/boost/pfr/detail/cast_to_layout_compatible.hpp
new file mode 100644
index 0000000000..1267495335
--- /dev/null
+++ b/include/boost/pfr/detail/cast_to_layout_compatible.hpp
@@ -0,0 +1,75 @@
+// Copyright (c) 2016-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_CAST_TO_LAYOUT_COMPATIBLE_HPP
+#define BOOST_PFR_DETAIL_CAST_TO_LAYOUT_COMPATIBLE_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <type_traits>
+#include <utility>      // metaprogramming stuff
+#include <boost/pfr/detail/rvalue_t.hpp>
+
+namespace boost { namespace pfr { namespace detail {
+
+template <class T, class U>
+constexpr void static_assert_layout_compatible() noexcept {
+    static_assert(
+        std::alignment_of<T>::value == std::alignment_of<U>::value,
+        "====================> Boost.PFR: Alignment check failed, probably your structure has user-defined alignment for the whole structure or for some of the fields."
+    );
+    static_assert(sizeof(T) == sizeof(U), "====================> Boost.PFR: Size check failed, probably your structure has bitfields or user-defined alignment.");
+}
+
+/// @cond
+#ifdef __GNUC__
+#define MAY_ALIAS __attribute__((__may_alias__))
+#else
+#define MAY_ALIAS
+#endif
+/// @endcond
+
+template <class To, class From>
+MAY_ALIAS const To& cast_to_layout_compatible(const From& val) noexcept {
+    MAY_ALIAS const To* const t = reinterpret_cast<const To*>( std::addressof(val) );
+    detail::static_assert_layout_compatible<To, From>();
+    return *t;
+}
+
+template <class To, class From>
+MAY_ALIAS const volatile To& cast_to_layout_compatible(const volatile From& val) noexcept {
+    MAY_ALIAS const volatile To* const t = reinterpret_cast<const volatile To*>( std::addressof(val) );
+    detail::static_assert_layout_compatible<To, From>();
+    return *t;
+}
+
+
+template <class To, class From>
+MAY_ALIAS volatile To& cast_to_layout_compatible(volatile From& val) noexcept {
+    MAY_ALIAS volatile To* const t = reinterpret_cast<volatile To*>( std::addressof(val) );
+    detail::static_assert_layout_compatible<To, From>();
+    return *t;
+}
+
+
+template <class To, class From>
+MAY_ALIAS To& cast_to_layout_compatible(From& val) noexcept {
+    MAY_ALIAS To* const t = reinterpret_cast<To*>( std::addressof(val) );
+    detail::static_assert_layout_compatible<To, From>();
+    return *t;
+}
+
+#ifdef BOOST_PFR_DETAIL_STRICT_RVALUE_TESTING
+template <class To, class From>
+To&& cast_to_layout_compatible(rvalue_t<From> val) noexcept = delete;
+#endif
+
+#undef MAY_ALIAS
+
+
+}}} // namespace boost::pfr::detail
+
+#endif // BOOST_PFR_DETAIL_CAST_TO_LAYOUT_COMPATIBLE_HPP
diff --git a/include/boost/pfr/detail/config.hpp b/include/boost/pfr/detail/config.hpp
new file mode 100644
index 0000000000..55f2bff4ce
--- /dev/null
+++ b/include/boost/pfr/detail/config.hpp
@@ -0,0 +1,80 @@
+// Copyright (c) 2016-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_CONFIG_HPP
+#define BOOST_PFR_DETAIL_CONFIG_HPP
+#pragma once
+
+#include <type_traits> // to get non standard platform macro definitions (__GLIBCXX__ for example)
+
+// Reminder:
+//  * MSVC++ 14.2 _MSC_VER == 1927 <- Loophole is known to work (Visual Studio ????)
+//  * MSVC++ 14.1 _MSC_VER == 1916 <- Loophole is known to NOT work (Visual Studio 2017)
+//  * MSVC++ 14.0 _MSC_VER == 1900 (Visual Studio 2015)
+//  * MSVC++ 12.0 _MSC_VER == 1800 (Visual Studio 2013)
+
+#if defined(_MSC_VER)
+#   if !defined(_MSVC_LANG) || _MSC_VER <= 1900
+#       error Boost.PFR library requires more modern MSVC compiler.
+#   endif
+#elif __cplusplus < 201402L
+#   error Boost.PFR library requires at least C++14.
+#endif
+
+#ifndef BOOST_PFR_USE_LOOPHOLE
+#   if defined(_MSC_VER)
+#       if _MSC_VER >= 1927
+#           define BOOST_PFR_USE_LOOPHOLE 1
+#       else
+#           define BOOST_PFR_USE_LOOPHOLE 0
+#       endif
+#   elif defined(__clang_major__) && __clang_major__ >= 8
+#       define BOOST_PFR_USE_LOOPHOLE 0
+#   else
+#       define BOOST_PFR_USE_LOOPHOLE 1
+#   endif
+#endif
+
+#ifndef BOOST_PFR_USE_CPP17
+#   ifdef __cpp_structured_bindings
+#       define BOOST_PFR_USE_CPP17 1
+#   elif defined(_MSVC_LANG)
+#       if _MSVC_LANG >= 201703L
+#           define BOOST_PFR_USE_CPP17 1
+#       else
+#           define BOOST_PFR_USE_CPP17 0
+#           if !BOOST_PFR_USE_LOOPHOLE
+#               error Boost.PFR requires /std:c++latest or /std:c++17 flags on your compiler.
+#           endif
+#       endif
+#   else
+#       define BOOST_PFR_USE_CPP17 0
+#   endif
+#endif
+
+#ifndef BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE
+// Assume that libstdc++ since GCC-7.3 does not have linear instantiation depth in std::make_integral_sequence
+#   if defined( __GLIBCXX__) && __GLIBCXX__ >= 20180101
+#       define BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE 1
+#   elif defined(_MSC_VER)
+#       define BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE 1
+//# elif other known working lib
+#   else
+#       define BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE 0
+#   endif
+#endif
+
+#if defined(__has_cpp_attribute)
+#   if __has_cpp_attribute(maybe_unused)
+#       define BOOST_PFR_MAYBE_UNUSED [[maybe_unused]]
+#   endif
+#endif
+
+#ifndef BOOST_PFR_MAYBE_UNUSED
+#   define BOOST_PFR_MAYBE_UNUSED
+#endif
+
+
+#endif // BOOST_PFR_DETAIL_CONFIG_HPP
diff --git a/include/boost/pfr/detail/core.hpp b/include/boost/pfr/detail/core.hpp
new file mode 100644
index 0000000000..6aabfb2deb
--- /dev/null
+++ b/include/boost/pfr/detail/core.hpp
@@ -0,0 +1,24 @@
+// Copyright (c) 2016-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_CORE_HPP
+#define BOOST_PFR_DETAIL_CORE_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+// Each core provides `boost::pfr::detail::tie_as_tuple` and
+// `boost::pfr::detail::for_each_field_dispatcher` functions.
+//
+// The whole PFR library is build on top of those two functions.
+#if BOOST_PFR_USE_CPP17
+#   include <boost/pfr/detail/core17.hpp>
+#elif BOOST_PFR_USE_LOOPHOLE
+#   include <boost/pfr/detail/core14_loophole.hpp>
+#else
+#   include <boost/pfr/detail/core14_classic.hpp>
+#endif
+
+#endif // BOOST_PFR_DETAIL_CORE_HPP
diff --git a/include/boost/pfr/detail/core14_classic.hpp b/include/boost/pfr/detail/core14_classic.hpp
new file mode 100644
index 0000000000..9349118b20
--- /dev/null
+++ b/include/boost/pfr/detail/core14_classic.hpp
@@ -0,0 +1,703 @@
+// Copyright (c) 2016-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_CORE14_CLASSIC_HPP
+#define BOOST_PFR_DETAIL_CORE14_CLASSIC_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <type_traits>
+#include <utility>      // metaprogramming stuff
+
+#include <boost/pfr/detail/sequence_tuple.hpp>
+#include <boost/pfr/detail/offset_based_getter.hpp>
+#include <boost/pfr/detail/fields_count.hpp>
+#include <boost/pfr/detail/make_flat_tuple_of_references.hpp>
+#include <boost/pfr/detail/make_integer_sequence.hpp>
+#include <boost/pfr/detail/size_array.hpp>
+#include <boost/pfr/detail/size_t_.hpp>
+#include <boost/pfr/detail/rvalue_t.hpp>
+
+#ifdef __clang__
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wmissing-braces"
+#   pragma clang diagnostic ignored "-Wundefined-inline"
+#   pragma clang diagnostic ignored "-Wundefined-internal"
+#   pragma clang diagnostic ignored "-Wmissing-field-initializers"
+#endif
+
+namespace boost { namespace pfr { namespace detail {
+
+///////////////////// General utility stuff
+
+template <class T> struct identity {
+    typedef T type;
+};
+
+template <class T>
+constexpr T construct_helper() noexcept { // adding const here allows to deal with copyable only types
+    return {};
+}
+
+template <class T> constexpr size_array<sizeof(T) * 3> fields_count_and_type_ids_with_zeros() noexcept;
+template <class T> constexpr auto flat_array_of_type_ids() noexcept;
+
+///////////////////// All the stuff for representing Type as integer and converting integer back to type
+namespace typeid_conversions {
+
+///////////////////// Helper constants and typedefs
+
+#ifdef _MSC_VER
+#   pragma warning( push )
+    // '<<': check operator precedence for possible error; use parentheses to clarify precedence
+#   pragma warning( disable : 4554 ) 
+#endif
+
+constexpr std::size_t native_types_mask = 31;
+constexpr std::size_t bits_per_extension = 3;
+constexpr std::size_t extension_mask = (
+    static_cast<std::size_t>((1 << bits_per_extension) - 1)
+        << static_cast<std::size_t>(sizeof(std::size_t) * 8 - bits_per_extension)
+);
+constexpr std::size_t native_ptr_type = (
+    static_cast<std::size_t>(1)
+        << static_cast<std::size_t>(sizeof(std::size_t) * 8 - bits_per_extension)
+);
+constexpr std::size_t native_const_ptr_type = (
+    static_cast<std::size_t>(2)
+        << static_cast<std::size_t>(sizeof(std::size_t) * 8 - bits_per_extension)
+);
+
+constexpr std::size_t native_const_volatile_ptr_type = (
+    static_cast<std::size_t>(3)
+        << static_cast<std::size_t>(sizeof(std::size_t) * 8 - bits_per_extension)
+);
+
+constexpr std::size_t native_volatile_ptr_type = (
+    static_cast<std::size_t>(4)
+        << static_cast<std::size_t>(sizeof(std::size_t) * 8 - bits_per_extension)
+);
+
+constexpr std::size_t native_ref_type = (
+    static_cast<std::size_t>(5)
+        << static_cast<std::size_t>(sizeof(std::size_t) * 8 - bits_per_extension)
+);
+
+template <std::size_t Index, std::size_t Extension>
+using if_extension = std::enable_if_t< (Index & extension_mask) == Extension >*;
+
+///////////////////// Helper functions
+template <std::size_t Unptr>
+constexpr std::size_t type_to_id_extension_apply(std::size_t ext) noexcept {
+    constexpr std::size_t native_id = (Unptr & native_types_mask);
+    constexpr std::size_t extensions = (Unptr & ~native_types_mask);
+    static_assert(
+        !((extensions >> bits_per_extension) & native_types_mask),
+        "====================> Boost.PFR: Too many extensions for a single field (something close to `int************************** p;` is in the POD type)."
+    );
+
+    return (extensions >> bits_per_extension) | native_id | ext;
+}
+
+template <std::size_t Index>
+using remove_1_ext = size_t_<
+    ((Index & ~native_types_mask) << bits_per_extension) | (Index & native_types_mask)
+>;
+
+#ifdef _MSC_VER
+#   pragma warning( pop )
+#endif
+
+///////////////////// Forward declarations
+
+template <class Type> constexpr std::size_t type_to_id(identity<Type*>) noexcept;
+template <class Type> constexpr std::size_t type_to_id(identity<const Type*>) noexcept;
+template <class Type> constexpr std::size_t type_to_id(identity<const volatile Type*>) noexcept;
+template <class Type> constexpr std::size_t type_to_id(identity<volatile Type*>) noexcept;
+template <class Type> constexpr std::size_t type_to_id(identity<Type&>) noexcept;
+template <class Type> constexpr std::size_t type_to_id(identity<Type>, std::enable_if_t<std::is_enum<Type>::value>* = 0) noexcept;
+template <class Type> constexpr std::size_t type_to_id(identity<Type>, std::enable_if_t<std::is_empty<Type>::value>* = 0) noexcept;
+template <class Type> constexpr std::size_t type_to_id(identity<Type>, std::enable_if_t<std::is_union<Type>::value>* = 0) noexcept;
+template <class Type> constexpr size_array<sizeof(Type) * 3> type_to_id(identity<Type>, std::enable_if_t<!std::is_enum<Type>::value && !std::is_empty<Type>::value && !std::is_union<Type>::value>* = 0) noexcept;
+
+template <std::size_t Index> constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_const_ptr_type> = 0) noexcept;
+template <std::size_t Index> constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_ptr_type> = 0) noexcept;
+template <std::size_t Index> constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_const_volatile_ptr_type> = 0) noexcept;
+template <std::size_t Index> constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_volatile_ptr_type> = 0) noexcept;
+template <std::size_t Index> constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_ref_type> = 0) noexcept;
+
+
+///////////////////// Definitions of type_to_id and id_to_type for fundamental types
+/// @cond
+#define BOOST_MAGIC_GET_REGISTER_TYPE(Type, Index)              \
+    constexpr std::size_t type_to_id(identity<Type>) noexcept { \
+        return Index;                                           \
+    }                                                           \
+    constexpr Type id_to_type( size_t_<Index > ) noexcept {     \
+        return detail::construct_helper<Type>();                \
+    }                                                           \
+    /**/
+/// @endcond
+
+
+// Register all base types here
+BOOST_MAGIC_GET_REGISTER_TYPE(unsigned char         , 1)
+BOOST_MAGIC_GET_REGISTER_TYPE(unsigned short        , 2)
+BOOST_MAGIC_GET_REGISTER_TYPE(unsigned int          , 3)
+BOOST_MAGIC_GET_REGISTER_TYPE(unsigned long         , 4)
+BOOST_MAGIC_GET_REGISTER_TYPE(unsigned long long    , 5)
+BOOST_MAGIC_GET_REGISTER_TYPE(signed char           , 6)
+BOOST_MAGIC_GET_REGISTER_TYPE(short                 , 7)
+BOOST_MAGIC_GET_REGISTER_TYPE(int                   , 8)
+BOOST_MAGIC_GET_REGISTER_TYPE(long                  , 9)
+BOOST_MAGIC_GET_REGISTER_TYPE(long long             , 10)
+BOOST_MAGIC_GET_REGISTER_TYPE(char                  , 11)
+BOOST_MAGIC_GET_REGISTER_TYPE(wchar_t               , 12)
+BOOST_MAGIC_GET_REGISTER_TYPE(char16_t              , 13)
+BOOST_MAGIC_GET_REGISTER_TYPE(char32_t              , 14)
+BOOST_MAGIC_GET_REGISTER_TYPE(float                 , 15)
+BOOST_MAGIC_GET_REGISTER_TYPE(double                , 16)
+BOOST_MAGIC_GET_REGISTER_TYPE(long double           , 17)
+BOOST_MAGIC_GET_REGISTER_TYPE(bool                  , 18)
+BOOST_MAGIC_GET_REGISTER_TYPE(void*                 , 19)
+BOOST_MAGIC_GET_REGISTER_TYPE(const void*           , 20)
+BOOST_MAGIC_GET_REGISTER_TYPE(volatile void*        , 21)
+BOOST_MAGIC_GET_REGISTER_TYPE(const volatile void*  , 22)
+BOOST_MAGIC_GET_REGISTER_TYPE(std::nullptr_t        , 23)
+constexpr std::size_t tuple_begin_tag               = 24;
+constexpr std::size_t tuple_end_tag                 = 25;
+
+#undef BOOST_MAGIC_GET_REGISTER_TYPE
+
+///////////////////// Definitions of type_to_id and id_to_type for types with extensions and nested types
+template <class Type>
+constexpr std::size_t type_to_id(identity<Type*>) noexcept {
+    constexpr auto unptr = typeid_conversions::type_to_id(identity<Type>{});
+    static_assert(
+        std::is_same<const std::size_t, decltype(unptr)>::value,
+        "====================> Boost.PFR: Pointers to user defined types are not supported."
+    );
+    return typeid_conversions::type_to_id_extension_apply<unptr>(native_ptr_type);
+}
+
+template <class Type>
+constexpr std::size_t type_to_id(identity<const Type*>) noexcept {
+    constexpr auto unptr = typeid_conversions::type_to_id(identity<Type>{});
+    static_assert(
+        std::is_same<const std::size_t, decltype(unptr)>::value,
+        "====================> Boost.PFR: Const pointers to user defined types are not supported."
+    );
+    return typeid_conversions::type_to_id_extension_apply<unptr>(native_const_ptr_type);
+}
+
+template <class Type>
+constexpr std::size_t type_to_id(identity<const volatile Type*>) noexcept {
+    constexpr auto unptr = typeid_conversions::type_to_id(identity<Type>{});
+    static_assert(
+        std::is_same<const std::size_t, decltype(unptr)>::value,
+        "====================> Boost.PFR: Const volatile pointers to user defined types are not supported."
+    );
+    return typeid_conversions::type_to_id_extension_apply<unptr>(native_const_volatile_ptr_type);
+}
+
+template <class Type>
+constexpr std::size_t type_to_id(identity<volatile Type*>) noexcept {
+    constexpr auto unptr = typeid_conversions::type_to_id(identity<Type>{});
+    static_assert(
+        std::is_same<const std::size_t, decltype(unptr)>::value,
+        "====================> Boost.PFR: Volatile pointers to user defined types are not supported."
+    );
+    return typeid_conversions::type_to_id_extension_apply<unptr>(native_volatile_ptr_type);
+}
+
+template <class Type>
+constexpr std::size_t type_to_id(identity<Type&>) noexcept {
+    constexpr auto unptr = typeid_conversions::type_to_id(identity<Type>{});
+    static_assert(
+        std::is_same<const std::size_t, decltype(unptr)>::value,
+        "====================> Boost.PFR: References to user defined types are not supported."
+    );
+    return typeid_conversions::type_to_id_extension_apply<unptr>(native_ref_type);
+}
+
+template <class Type>
+constexpr std::size_t type_to_id(identity<Type>, std::enable_if_t<std::is_enum<Type>::value>*) noexcept {
+    return typeid_conversions::type_to_id(identity<typename std::underlying_type<Type>::type >{});
+}
+
+template <class Type>
+constexpr std::size_t type_to_id(identity<Type>, std::enable_if_t<std::is_empty<Type>::value>*) noexcept {
+    static_assert(!std::is_empty<Type>::value, "====================> Boost.PFR: Empty classes/structures as members are not supported.");
+    return 0;
+}
+
+template <class Type>
+constexpr std::size_t type_to_id(identity<Type>, std::enable_if_t<std::is_union<Type>::value>*) noexcept {
+    static_assert(
+        !std::is_union<Type>::value,
+        "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info."
+    );
+    return 0;
+}
+
+template <class Type>
+constexpr size_array<sizeof(Type) * 3> type_to_id(identity<Type>, std::enable_if_t<!std::is_enum<Type>::value && !std::is_empty<Type>::value && !std::is_union<Type>::value>*) noexcept {
+    constexpr auto t = detail::flat_array_of_type_ids<Type>();
+    size_array<sizeof(Type) * 3> result {{tuple_begin_tag}};
+    constexpr bool requires_tuplening = (
+        (t.count_nonzeros() != 1)  || (t.count_nonzeros() == t.count_from_opening_till_matching_parenthis_seq(0, tuple_begin_tag, tuple_end_tag))
+    );
+
+    if (requires_tuplening) {
+        for (std::size_t i = 0; i < t.size(); ++i)
+            result.data[i + 1] = t.data[i];
+        result.data[result.size() - 1] = tuple_end_tag;
+    } else {
+        for (std::size_t i = 0; i < t.size(); ++i)
+            result.data[i] = t.data[i];
+    }
+    return result;
+}
+
+
+
+template <std::size_t Index>
+constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_ptr_type>) noexcept {
+    typedef decltype( typeid_conversions::id_to_type(remove_1_ext<Index>()) )* res_t;
+    return detail::construct_helper<res_t>();
+}
+
+template <std::size_t Index>
+constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_const_ptr_type>) noexcept {
+    typedef const decltype( typeid_conversions::id_to_type(remove_1_ext<Index>()) )* res_t;
+    return detail::construct_helper<res_t>();
+}
+
+template <std::size_t Index>
+constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_const_volatile_ptr_type>) noexcept {
+    typedef const volatile decltype( typeid_conversions::id_to_type(remove_1_ext<Index>()) )* res_t;
+    return detail::construct_helper<res_t>();
+}
+
+
+template <std::size_t Index>
+constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_volatile_ptr_type>) noexcept {
+    typedef volatile decltype( typeid_conversions::id_to_type(remove_1_ext<Index>()) )* res_t;
+    return detail::construct_helper<res_t>();
+}
+
+
+template <std::size_t Index>
+constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_ref_type>) noexcept {
+    static_assert(!Index, "====================> Boost.PFR: References are not supported");
+    return nullptr;
+}
+
+} // namespace typeid_conversions
+
+///////////////////// Structure that remembers types as integers on a `constexpr operator Type()` call
+struct ubiq_val {
+    std::size_t* ref_;
+
+    template <class T>
+    constexpr void assign(const T& typeids) const noexcept {
+        for (std::size_t i = 0; i < T::size(); ++i)
+            ref_[i] = typeids.data[i];
+    }
+
+    constexpr void assign(std::size_t val) const noexcept {
+        ref_[0] = val;
+    }
+
+    template <class Type>
+    constexpr operator Type() const noexcept {
+        constexpr auto typeids = typeid_conversions::type_to_id(identity<Type>{});
+        assign(typeids);
+        return detail::construct_helper<Type>();
+    }
+};
+
+///////////////////// Structure that remembers size of the type on a `constexpr operator Type()` call
+struct ubiq_sizes {
+    std::size_t& ref_;
+
+    template <class Type>
+    constexpr operator Type() const noexcept {
+        ref_ = sizeof(Type);
+        return detail::construct_helper<Type>();
+    }
+};
+
+///////////////////// Returns array of (offsets without accounting alignments). Required for keeping places for nested type ids
+template <class T, std::size_t N, std::size_t... I>
+constexpr size_array<N> get_type_offsets() noexcept {
+    typedef size_array<N> array_t;
+    array_t sizes{};
+    T tmp{ ubiq_sizes{sizes.data[I]}... };
+    (void)tmp;
+
+    array_t offsets{{0}};
+    for (std::size_t i = 1; i < N; ++i)
+        offsets.data[i] = offsets.data[i - 1] + sizes.data[i - 1];
+
+    return offsets;
+}
+
+///////////////////// Returns array of typeids and zeros if construtor of a type accepts sizeof...(I) parameters
+template <class T, std::size_t N, std::size_t... I>
+constexpr void* flat_type_to_array_of_type_ids(std::size_t* types, std::index_sequence<I...>) noexcept
+{
+    static_assert(
+        N <= sizeof(T),
+        "====================> Boost.PFR: Bit fields are not supported."
+    );
+
+    constexpr auto offsets = detail::get_type_offsets<T, N, I...>();
+    T tmp{ ubiq_val{types + get<I>(offsets) * 3}... };
+    (void)types;
+    (void)tmp;
+    (void)offsets; // If type is empty offsets are not used
+    return nullptr;
+}
+
+///////////////////// Returns array of typeids and zeros
+template <class T>
+constexpr size_array<sizeof(T) * 3> fields_count_and_type_ids_with_zeros() noexcept {
+    size_array<sizeof(T) * 3> types{};
+    constexpr std::size_t N = detail::fields_count<T>();
+    detail::flat_type_to_array_of_type_ids<T, N>(types.data, detail::make_index_sequence<N>());
+    return types;
+}
+
+///////////////////// Returns array of typeids without zeros
+template <class T>
+constexpr auto flat_array_of_type_ids() noexcept {
+    constexpr auto types = detail::fields_count_and_type_ids_with_zeros<T>();
+    constexpr std::size_t count = types.count_nonzeros();
+    size_array<count> res{};
+    std::size_t j = 0;
+    for (std::size_t i = 0; i < decltype(types)::size(); ++i) {
+        if (types.data[i]) {
+            res.data[j] = types.data[i];
+            ++ j;
+        }
+    }
+
+    return res;
+}
+
+///////////////////// Convert array of typeids into sequence_tuple::tuple
+
+template <class T, std::size_t First, std::size_t... I>
+constexpr auto as_flat_tuple_impl(std::index_sequence<First, I...>) noexcept;
+
+template <class T>
+constexpr sequence_tuple::tuple<> as_flat_tuple_impl(std::index_sequence<>) noexcept {
+    return sequence_tuple::tuple<>{};
+}
+
+template <std::size_t Increment, std::size_t... I>
+constexpr auto increment_index_sequence(std::index_sequence<I...>) noexcept {
+    return std::index_sequence<I + Increment...>{};
+}
+
+template <class T, std::size_t V, std::size_t I, std::size_t SubtupleLength>
+constexpr auto prepare_subtuples(size_t_<V>, size_t_<I>, size_t_<SubtupleLength>) noexcept {
+    static_assert(SubtupleLength == 0, "====================> Boost.PFR: Internal error while representing nested field as tuple");
+    return typeid_conversions::id_to_type(size_t_<V>{});
+}
+
+template <class T, std::size_t I, std::size_t SubtupleLength>
+constexpr auto prepare_subtuples(size_t_<typeid_conversions::tuple_end_tag>, size_t_<I>, size_t_<SubtupleLength>) noexcept {
+    static_assert(sizeof(T) == 0, "====================> Boost.PFR: Internal error while representing nested field as tuple");
+    return int{};
+}
+
+template <class T, std::size_t I, std::size_t SubtupleLength>
+constexpr auto prepare_subtuples(size_t_<typeid_conversions::tuple_begin_tag>, size_t_<I>, size_t_<SubtupleLength>) noexcept {
+    static_assert(SubtupleLength > 2, "====================> Boost.PFR: Internal error while representing nested field as tuple");
+    constexpr auto seq = detail::make_index_sequence<SubtupleLength - 2>{};
+    return detail::as_flat_tuple_impl<T>( detail::increment_index_sequence<I + 1>(seq) );
+}
+
+
+template <class Array>
+constexpr Array remove_subtuples(Array indexes_plus_1, const Array& subtuple_lengths) noexcept {
+    for (std::size_t i = 0; i < subtuple_lengths.size(); ++i) {
+        if (subtuple_lengths.data[i]) {
+            const std::size_t skips_count = subtuple_lengths.data[i];
+            for (std::size_t j = i + 1; j < skips_count + i; ++j) {
+                indexes_plus_1.data[j] = 0;
+            }
+            i += skips_count - 1;
+        }
+    }
+    return indexes_plus_1;
+}
+
+template <std::size_t N, class Array>
+constexpr size_array<N> resize_dropping_zeros_and_decrementing(size_t_<N>, const Array& a) noexcept {
+    size_array<N> result{};
+    std::size_t result_indx = 0;
+    for (std::size_t i = 0; i < a.size(); ++i) {
+        if (a.data[i]) {
+            result.data[result_indx] = static_cast<std::size_t>(a.data[i] - 1);
+            ++ result_indx;
+        }
+    }
+
+    return result;
+}
+
+template <class T, std::size_t First, std::size_t... I, std::size_t... INew>
+constexpr auto as_flat_tuple_impl_drop_helpers(std::index_sequence<First, I...>, std::index_sequence<INew...>) noexcept {
+    constexpr auto a = detail::flat_array_of_type_ids<T>();
+
+    constexpr size_array<sizeof...(I) + 1> subtuples_length {{
+        a.count_from_opening_till_matching_parenthis_seq(First, typeid_conversions::tuple_begin_tag, typeid_conversions::tuple_end_tag),
+        a.count_from_opening_till_matching_parenthis_seq(I, typeid_conversions::tuple_begin_tag, typeid_conversions::tuple_end_tag)...
+    }};
+
+    constexpr size_array<sizeof...(I) + 1> type_indexes_with_subtuple_internals {{ 1, 1 + I - First...}};
+    constexpr auto type_indexes_plus_1_and_zeros_as_skips = detail::remove_subtuples(type_indexes_with_subtuple_internals, subtuples_length);
+    constexpr auto new_size = size_t_<type_indexes_plus_1_and_zeros_as_skips.count_nonzeros()>{};
+    constexpr auto type_indexes = detail::resize_dropping_zeros_and_decrementing(new_size, type_indexes_plus_1_and_zeros_as_skips);
+
+    typedef sequence_tuple::tuple<
+        decltype(detail::prepare_subtuples<T>(
+            size_t_< a.data[ First + type_indexes.data[INew] ]          >{},    // id of type
+            size_t_< First + type_indexes.data[INew]                    >{},    // index of current id in `a`
+            size_t_< subtuples_length.data[ type_indexes.data[INew] ]   >{}     // if id of type is tuple, then length of that tuple
+        ))...
+    > subtuples_uncleanuped_t;
+
+    return subtuples_uncleanuped_t{};
+}
+
+template <class Array>
+constexpr std::size_t count_skips_in_array(std::size_t begin_index, std::size_t end_index, const Array& a) noexcept {
+    std::size_t skips = 0;
+    for (std::size_t i = begin_index; i < end_index; ++i) {
+        if (a.data[i] == typeid_conversions::tuple_begin_tag) {
+            const std::size_t this_tuple_size = a.count_from_opening_till_matching_parenthis_seq(i, typeid_conversions::tuple_begin_tag, typeid_conversions::tuple_end_tag) - 1;
+            skips += this_tuple_size;
+            i += this_tuple_size - 1;
+        }
+    }
+
+    return skips;
+}
+
+template <class T, std::size_t First, std::size_t... I>
+constexpr auto as_flat_tuple_impl(std::index_sequence<First, I...>) noexcept {
+    constexpr auto a = detail::flat_array_of_type_ids<T>();
+    constexpr std::size_t count_of_I = sizeof...(I);
+
+    return detail::as_flat_tuple_impl_drop_helpers<T>(
+        std::index_sequence<First, I...>{},
+        detail::make_index_sequence< 1 + count_of_I - count_skips_in_array(First, First + count_of_I, a) >{}
+    );
+}
+
+template <class T>
+constexpr auto internal_tuple_with_same_alignment() noexcept {
+    typedef typename std::remove_cv<T>::type type;
+
+    static_assert(
+        std::is_trivial<type>::value && std::is_standard_layout<type>::value,
+        "====================> Boost.PFR: Type can not be reflected without Loophole or C++17, because it's not POD"
+    );
+    static_assert(!std::is_reference<type>::value, "====================> Boost.PFR: Not applyable");
+    constexpr auto res = detail::as_flat_tuple_impl<type>(
+        detail::make_index_sequence< decltype(detail::flat_array_of_type_ids<type>())::size() >()
+    );
+
+    return res;
+}
+
+template <class T>
+using internal_tuple_with_same_alignment_t = decltype( detail::internal_tuple_with_same_alignment<T>() );
+
+
+///////////////////// Flattening
+struct ubiq_is_flat_refelectable {
+    bool& is_flat_refelectable;
+
+    template <class Type>
+    constexpr operator Type() const noexcept {
+        is_flat_refelectable = std::is_fundamental<std::remove_pointer_t<Type>>::value;
+        return {};
+    }
+};
+
+template <class T, std::size_t... I>
+constexpr bool is_flat_refelectable(std::index_sequence<I...>) noexcept {
+    constexpr std::size_t fields = sizeof...(I);
+    bool result[fields] = {static_cast<bool>(I)...};
+    const T v{ ubiq_is_flat_refelectable{result[I]}... };
+    (void)v;
+
+    for (std::size_t i = 0; i < fields; ++i) {
+        if (!result[i]) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+template <class T>
+auto tie_as_flat_tuple(T& lvalue) noexcept {
+    static_assert(
+        !std::is_union<T>::value,
+        "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info."
+    );
+    using type = std::remove_cv_t<T>;
+    using tuple_type = internal_tuple_with_same_alignment_t<type>;
+
+    offset_based_getter<type, tuple_type> getter;
+    return boost::pfr::detail::make_flat_tuple_of_references(lvalue, getter, size_t_<0>{}, size_t_<tuple_type::size_v>{});
+}
+
+template <class T>
+auto tie_as_tuple(T& val) noexcept {
+    static_assert(
+        !std::is_union<T>::value,
+        "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info."
+    );
+    static_assert(
+        boost::pfr::detail::is_flat_refelectable<T>( detail::make_index_sequence<boost::pfr::detail::fields_count<T>()>{} ),
+        "====================> Boost.PFR: Not possible in C++14 to represent that type without loosing information. Change type definition or enable C++17"
+    );
+    return boost::pfr::detail::tie_as_flat_tuple(val);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////// Structure that can be converted to copy of anything
+struct ubiq_constructor_constexpr_copy {
+    std::size_t ignore;
+
+    template <class Type>
+    constexpr operator Type() const noexcept {
+        static_assert(
+            std::is_trivially_destructible<Type>::value,
+            "====================> Boost.PFR: One of the fields in the type passed to `for_each_field` has non trivial destructor."
+        );
+        return {};
+    }
+};
+
+/////////////////////
+
+template <class T, std::size_t... I>
+struct is_constexpr_aggregate_initializable { // TODO: try to fix it
+    template <T = T{ ubiq_constructor_constexpr_copy{I}... } >
+    static std::true_type test(long) noexcept;
+
+    static std::false_type test(...) noexcept;
+
+    static constexpr decltype( test(0) ) value{};
+};
+
+
+template <class T, class F, std::size_t I0, std::size_t... I, class... Fields>
+void for_each_field_in_depth(T& t, F&& f, std::index_sequence<I0, I...>, identity<Fields>...);
+
+template <class T, class F, class... Fields>
+void for_each_field_in_depth(T& t, F&& f, std::index_sequence<>, identity<Fields>...);
+
+template <class T, class F, class IndexSeq, class... Fields>
+struct next_step {
+    T& t;
+    F& f;
+
+    template <class Field>
+    operator Field() const {
+         boost::pfr::detail::for_each_field_in_depth(
+             t,
+             std::forward<F>(f),
+             IndexSeq{},
+             identity<Fields>{}...,
+             identity<Field>{}
+         );
+
+         return {};
+    }
+};
+
+template <class T, class F, std::size_t I0, std::size_t... I, class... Fields>
+void for_each_field_in_depth(T& t, F&& f, std::index_sequence<I0, I...>, identity<Fields>...) {
+    (void)std::add_const_t<std::remove_reference_t<T>>{
+        Fields{}...,
+        next_step<T, F, std::index_sequence<I...>, Fields...>{t, f},
+        ubiq_constructor_constexpr_copy{I}...
+    };
+}
+
+template <class T, class F, class... Fields>
+void for_each_field_in_depth(T& lvalue, F&& f, std::index_sequence<>, identity<Fields>...) {
+    using tuple_type = sequence_tuple::tuple<Fields...>;
+
+    offset_based_getter<std::remove_cv_t<std::remove_reference_t<T>>, tuple_type> getter;
+    std::forward<F>(f)(
+        boost::pfr::detail::make_flat_tuple_of_references(lvalue, getter, size_t_<0>{}, size_t_<sizeof...(Fields)>{})
+    );
+}
+
+template <class T, class F, std::size_t... I>
+void for_each_field_dispatcher_1(T& t, F&& f, std::index_sequence<I...>, std::true_type /*is_flat_refelectable*/) {
+    std::forward<F>(f)(
+        boost::pfr::detail::tie_as_flat_tuple(t)
+    );
+}
+
+
+template <class T, class F, std::size_t... I>
+void for_each_field_dispatcher_1(T& t, F&& f, std::index_sequence<I...>, std::false_type /*is_flat_refelectable*/) {
+    boost::pfr::detail::for_each_field_in_depth(
+        t,
+        std::forward<F>(f),
+        std::index_sequence<I...>{}
+    );
+}
+
+template <class T, class F, std::size_t... I>
+void for_each_field_dispatcher(T& t, F&& f, std::index_sequence<I...>) {
+    static_assert(
+        !std::is_union<T>::value,
+        "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info."
+    );
+
+    /// Compile time error at this point means that you have called `for_each_field` or some other non-flat function or operator for a
+    /// type that is not constexpr aggregate initializable.
+    ///
+    /// Make sure that all the fields of your type have constexpr default construtors and trivial destructors.
+    /// Or compile in C++17 mode.
+    constexpr T tmp{ ubiq_constructor_constexpr_copy{I}... };
+    (void)tmp;
+
+    //static_assert(is_constexpr_aggregate_initializable<T, I...>::value, "====================> Boost.PFR: T must be a constexpr initializable type");
+
+    constexpr bool is_flat_refelectable_val = detail::is_flat_refelectable<T>( std::index_sequence<I...>{} );
+    detail::for_each_field_dispatcher_1(
+        t,
+        std::forward<F>(f),
+        std::index_sequence<I...>{},
+        std::integral_constant<bool, is_flat_refelectable_val>{}
+    );
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+#ifdef __clang__
+#   pragma clang diagnostic pop
+#endif
+
+}}} // namespace boost::pfr::detail
+
+#endif // BOOST_PFR_DETAIL_CORE14_CLASSIC_HPP
diff --git a/include/boost/pfr/detail/core14_loophole.hpp b/include/boost/pfr/detail/core14_loophole.hpp
new file mode 100644
index 0000000000..7920c7b1a2
--- /dev/null
+++ b/include/boost/pfr/detail/core14_loophole.hpp
@@ -0,0 +1,200 @@
+// Copyright (c) 2017-2018 Alexandr Poltavsky, Antony Polukhin.
+// Copyright (c) 2019-2020 Antony Polukhin.
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+// The Great Type Loophole (C++14)
+// Initial implementation by Alexandr Poltavsky, http://alexpolt.github.io
+//
+// Description: 
+//  The Great Type Loophole is a technique that allows to exchange type information with template
+//  instantiations. Basically you can assign and read type information during compile time.
+//  Here it is used to detect data members of a data type. I described it for the first time in
+//  this blog post http://alexpolt.github.io/type-loophole.html .
+//
+// This technique exploits the http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#2118
+// CWG 2118. Stateful metaprogramming via friend injection
+// Note: CWG agreed that such techniques should be ill-formed, although the mechanism for prohibiting them is as yet undetermined.
+
+#ifndef BOOST_PFR_DETAIL_CORE14_LOOPHOLE_HPP
+#define BOOST_PFR_DETAIL_CORE14_LOOPHOLE_HPP
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <type_traits>
+#include <utility>
+
+#include <boost/pfr/detail/cast_to_layout_compatible.hpp> // still needed for enums
+#include <boost/pfr/detail/offset_based_getter.hpp>
+#include <boost/pfr/detail/fields_count.hpp>
+#include <boost/pfr/detail/make_flat_tuple_of_references.hpp>
+#include <boost/pfr/detail/make_integer_sequence.hpp>
+#include <boost/pfr/detail/sequence_tuple.hpp>
+#include <boost/pfr/detail/rvalue_t.hpp>
+#include <boost/pfr/detail/unsafe_declval.hpp>
+
+
+#ifdef __clang__
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wmissing-braces"
+#   pragma clang diagnostic ignored "-Wundefined-inline"
+#   pragma clang diagnostic ignored "-Wundefined-internal"
+#   pragma clang diagnostic ignored "-Wmissing-field-initializers"
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   pragma GCC diagnostic ignored "-Wnon-template-friend"
+#endif
+
+
+namespace boost { namespace pfr { namespace detail {
+
+// tag<T,N> generates friend declarations and helps with overload resolution.
+// There are two types: one with the auto return type, which is the way we read types later.
+// The second one is used in the detection of instantiations without which we'd get multiple
+// definitions.
+
+template <class T, std::size_t N>
+struct tag {
+    friend auto loophole(tag<T,N>);
+};
+
+// The definitions of friend functions.
+template <class T, class U, std::size_t N, bool B>
+struct fn_def_lref {
+    friend auto loophole(tag<T,N>) {
+        // Standard Library containers do not SFINAE on invalid copy constructor. Because of that std::vector<std::unique_ptr<int>> reports that it is copyable,
+        // which leads to an instantiation error at this place.
+        //
+        // To workaround the issue, we check that the type U is movable, and move it in that case.
+        using no_extents_t = std::remove_all_extents_t<U>;
+        return static_cast< std::conditional_t<std::is_move_constructible<no_extents_t>::value, no_extents_t&&, no_extents_t&> >(
+            boost::pfr::detail::unsafe_declval<no_extents_t&>()
+        );
+    }
+};
+template <class T, class U, std::size_t N, bool B>
+struct fn_def_rref {
+    friend auto loophole(tag<T,N>) { return std::move(boost::pfr::detail::unsafe_declval< std::remove_all_extents_t<U>& >()); }
+};
+
+
+// Those specializations are to avoid multiple definition errors.
+template <class T, class U, std::size_t N>
+struct fn_def_lref<T, U, N, true> {};
+
+template <class T, class U, std::size_t N>
+struct fn_def_rref<T, U, N, true> {};
+
+
+// This has a templated conversion operator which in turn triggers instantiations.
+// Important point, using sizeof seems to be more reliable. Also default template
+// arguments are "cached" (I think). To fix that I provide a U template parameter to
+// the ins functions which do the detection using constexpr friend functions and SFINAE.
+template <class T, std::size_t N>
+struct loophole_ubiq_lref {
+    template<class U, std::size_t M> static std::size_t ins(...);
+    template<class U, std::size_t M, std::size_t = sizeof(loophole(tag<T,M>{})) > static char ins(int);
+
+    template<class U, std::size_t = sizeof(fn_def_lref<T, U, N, sizeof(ins<U, N>(0)) == sizeof(char)>)>
+    constexpr operator U&() const&& noexcept; // `const&&` here helps to avoid ambiguity in loophole instantiations. optional_like test validate that behavior.
+};
+
+template <class T, std::size_t N>
+struct loophole_ubiq_rref {
+    template<class U, std::size_t M> static std::size_t ins(...);
+    template<class U, std::size_t M, std::size_t = sizeof(loophole(tag<T,M>{})) > static char ins(int);
+
+    template<class U, std::size_t = sizeof(fn_def_rref<T, U, N, sizeof(ins<U, N>(0)) == sizeof(char)>)>
+    constexpr operator U&&() const&& noexcept; // `const&&` here helps to avoid ambiguity in loophole instantiations. optional_like test validate that behavior.
+};
+
+
+// This is a helper to turn a data structure into a tuple.
+template <class T, class U>
+struct loophole_type_list_lref;
+
+template <typename T, std::size_t... I>
+struct loophole_type_list_lref< T, std::index_sequence<I...> >
+     // Instantiating loopholes:
+    : sequence_tuple::tuple< decltype(T{ loophole_ubiq_lref<T, I>{}... }, 0) >
+{
+    using type = sequence_tuple::tuple< decltype(loophole(tag<T, I>{}))... >;
+};
+
+
+template <class T, class U>
+struct loophole_type_list_rref;
+
+template <typename T, std::size_t... I>
+struct loophole_type_list_rref< T, std::index_sequence<I...> >
+     // Instantiating loopholes:
+    : sequence_tuple::tuple< decltype(T{ loophole_ubiq_rref<T, I>{}... }, 0) >
+{
+    using type = sequence_tuple::tuple< decltype(loophole(tag<T, I>{}))... >;
+};
+
+
+// Lazily returns loophole_type_list_{lr}ref.
+template <bool IsCopyConstructible /*= true*/, class T, class U>
+struct loophole_type_list_selector {
+    using type = loophole_type_list_lref<T, U>;
+};
+
+template <class T, class U>
+struct loophole_type_list_selector<false /*IsCopyConstructible*/, T, U> {
+    using type = loophole_type_list_rref<T, U>;
+};
+
+template <class T>
+auto tie_as_tuple_loophole_impl(T& lvalue) noexcept {
+    using type = std::remove_cv_t<std::remove_reference_t<T>>;
+    using indexes = detail::make_index_sequence<fields_count<type>()>;
+    using loophole_type_list = typename detail::loophole_type_list_selector<
+        std::is_copy_constructible<std::remove_all_extents_t<type>>::value, type, indexes
+    >::type;
+    using tuple_type = typename loophole_type_list::type;
+
+    return boost::pfr::detail::make_flat_tuple_of_references(
+        lvalue,
+        offset_based_getter<type, tuple_type>{},
+        size_t_<0>{},
+        size_t_<tuple_type::size_v>{}
+    );
+}
+
+template <class T>
+auto tie_as_tuple(T& val) noexcept {
+    static_assert(
+        !std::is_union<T>::value,
+        "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info."
+    );
+    return boost::pfr::detail::tie_as_tuple_loophole_impl(
+        val
+    );
+}
+
+template <class T, class F, std::size_t... I>
+void for_each_field_dispatcher(T& t, F&& f, std::index_sequence<I...>) {
+    static_assert(
+        !std::is_union<T>::value,
+        "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info."
+    );
+    std::forward<F>(f)(
+        boost::pfr::detail::tie_as_tuple_loophole_impl(t)
+    );
+}
+
+}}} // namespace boost::pfr::detail
+
+
+#ifdef __clang__
+#   pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic pop
+#endif
+
+
+#endif // BOOST_PFR_DETAIL_CORE14_LOOPHOLE_HPP
+
diff --git a/include/boost/pfr/detail/core17.hpp b/include/boost/pfr/detail/core17.hpp
new file mode 100644
index 0000000000..16a2c15c07
--- /dev/null
+++ b/include/boost/pfr/detail/core17.hpp
@@ -0,0 +1,71 @@
+// Copyright (c) 2016-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+#ifndef BOOST_PFR_DETAIL_CORE17_HPP
+#define BOOST_PFR_DETAIL_CORE17_HPP
+
+#include <boost/pfr/detail/core17_generated.hpp>
+#include <boost/pfr/detail/fields_count.hpp>
+#include <boost/pfr/detail/for_each_field_impl.hpp>
+#include <boost/pfr/detail/rvalue_t.hpp>
+
+namespace boost { namespace pfr { namespace detail {
+
+#ifndef _MSC_VER // MSVC fails to compile the following code, but compiles the structured bindings in core17_generated.hpp
+struct do_not_define_std_tuple_size_for_me {
+    bool test1 = true;
+};
+
+template <class T>
+constexpr bool do_structured_bindings_work() noexcept { // ******************************************* IN CASE OF ERROR READ THE FOLLOWING LINES IN boost/pfr/detail/core17.hpp FILE:
+    T val{};
+    const auto& [a] = val; // ******************************************* IN CASE OF ERROR READ THE FOLLOWING LINES IN boost/pfr/detail/core17.hpp FILE:
+
+    /****************************************************************************
+    *
+    * It looks like your compiler or Standard Library can not handle C++17
+    * structured bindings.
+    *
+    * Workaround: Define BOOST_PFR_USE_CPP17 to 0
+    * It will disable the C++17 features for Boost.PFR library.
+    *
+    * Sorry for the inconvenience caused.
+    *
+    ****************************************************************************/
+
+    return a;
+}
+
+static_assert(
+    do_structured_bindings_work<do_not_define_std_tuple_size_for_me>(),
+    "====================> Boost.PFR: Your compiler can not handle C++17 structured bindings. Read the above comments for workarounds."
+);
+#endif // #ifndef _MSC_VER
+
+template <class T>
+constexpr auto tie_as_tuple(T& val) noexcept {
+  static_assert(
+    !std::is_union<T>::value,
+    "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info."
+  );
+  typedef size_t_<boost::pfr::detail::fields_count<T>()> fields_count_tag;
+  return boost::pfr::detail::tie_as_tuple(val, fields_count_tag{});
+}
+
+template <class T, class F, std::size_t... I>
+void for_each_field_dispatcher(T& t, F&& f, std::index_sequence<I...>) {
+    static_assert(
+        !std::is_union<T>::value,
+        "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info."
+    );
+    std::forward<F>(f)(
+        detail::tie_as_tuple(t)
+    );
+}
+
+}}} // namespace boost::pfr::detail
+
+#endif // BOOST_PFR_DETAIL_CORE17_HPP
diff --git a/include/boost/pfr/detail/core17_generated.hpp b/include/boost/pfr/detail/core17_generated.hpp
new file mode 100644
index 0000000000..b4e26fcc41
--- /dev/null
+++ b/include/boost/pfr/detail/core17_generated.hpp
@@ -0,0 +1,1036 @@
+// Copyright (c) 2016-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////// THIS HEADER IS AUTO GENERATED BY misc/generate_cpp17.py                                    ////////////////
+//////////////// MODIFY AND RUN THE misc/generate_cpp17.py INSTEAD OF DIRECTLY MODIFYING THE GENERATED FILE ////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_PFR_DETAIL_CORE17_GENERATED_HPP
+#define BOOST_PFR_DETAIL_CORE17_GENERATED_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+#if !BOOST_PFR_USE_CPP17
+#   error C++17 is required for this header.
+#endif
+
+#include <boost/pfr/detail/sequence_tuple.hpp>
+#include <boost/pfr/detail/size_t_.hpp>
+
+namespace boost { namespace pfr { namespace detail {
+
+template <class... Args>
+constexpr auto make_tuple_of_references(Args&&... args) noexcept {
+  return sequence_tuple::tuple<Args&...>{ args... };
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& /*val*/, size_t_<0>) noexcept {
+  return sequence_tuple::tuple<>{};
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<1>, std::enable_if_t<std::is_class< std::remove_cv_t<T> >::value>* = 0) noexcept {
+  auto& [a] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a);
+}
+
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<1>, std::enable_if_t<!std::is_class< std::remove_cv_t<T> >::value>* = 0) noexcept {
+  return ::boost::pfr::detail::make_tuple_of_references( val );
+}
+
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<2>) noexcept {
+  auto& [a,b] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<3>) noexcept {
+  auto& [a,b,c] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<4>) noexcept {
+  auto& [a,b,c,d] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<5>) noexcept {
+  auto& [a,b,c,d,e] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<6>) noexcept {
+  auto& [a,b,c,d,e,f] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<7>) noexcept {
+  auto& [a,b,c,d,e,f,g] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<8>) noexcept {
+  auto& [a,b,c,d,e,f,g,h] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<9>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<10>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<11>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<12>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<13>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<14>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<15>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<16>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<17>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<18>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<19>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<20>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<21>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<22>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<23>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<24>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<25>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<26>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<27>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<28>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<29>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<30>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<31>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<32>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<33>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<34>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<35>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<36>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<37>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<38>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<39>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<40>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<41>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<42>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<43>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<44>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<45>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<46>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<47>) noexcept {
+  auto& [a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z);
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<48>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<49>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<50>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<51>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<52>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<53>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<54>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<55>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<56>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<57>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<58>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<59>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<60>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<61>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<62>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<63>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<64>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<65>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<66>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<67>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<68>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<69>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<70>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<71>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<72>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<73>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<74>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<75>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<76>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<77>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<78>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<79>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<80>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<81>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<82>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<83>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<84>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<85>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<86>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<87>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<88>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<89>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<90>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<91>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<92>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<93>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX,aY
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX,aY
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<94>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX,aY,aZ
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX,aY,aZ
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<95>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX,aY,aZ,
+    ba
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX,aY,aZ,
+    ba
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<96>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX,aY,aZ,
+    ba,bb
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX,aY,aZ,
+    ba,bb
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<97>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX,aY,aZ,
+    ba,bb,bc
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX,aY,aZ,
+    ba,bb,bc
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<98>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX,aY,aZ,
+    ba,bb,bc,bd
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX,aY,aZ,
+    ba,bb,bc,bd
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<99>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX,aY,aZ,
+    ba,bb,bc,bd,be
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX,aY,aZ,
+    ba,bb,bc,bd,be
+  );
+}
+
+template <class T>
+constexpr auto tie_as_tuple(T& val, size_t_<100>) noexcept {
+  auto& [
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX,aY,aZ,
+    ba,bb,bc,bd,be,bf
+  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+
+  return ::boost::pfr::detail::make_tuple_of_references(
+    a,b,c,d,e,f,g,h,j,k,l,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,U,V,W,X,Y,Z,
+    aa,ab,ac,ad,ae,af,ag,ah,aj,ak,al,am,an,ap,aq,ar,as,at,au,av,aw,ax,ay,az,aA,aB,aC,aD,aE,aF,aG,aH,aJ,aK,aL,aM,aN,aP,aQ,aR,aS,aU,aV,aW,aX,aY,aZ,
+    ba,bb,bc,bd,be,bf
+  );
+}
+
+
+template <class T, std::size_t I>
+constexpr void tie_as_tuple(T& /*val*/, size_t_<I>) noexcept {
+  static_assert(sizeof(T) && false,
+                "====================> Boost.PFR: Too many fields in a structure T. Regenerate include/boost/pfr/detail/core17_generated.hpp file for appropriate count of fields. For example: `python ./misc/generate_cpp17.py 300 > include/boost/pfr/detail/core17_generated.hpp`");
+}
+
+}}} // namespace boost::pfr::detail
+
+#endif // BOOST_PFR_DETAIL_CORE17_GENERATED_HPP
+
diff --git a/include/boost/pfr/detail/detectors.hpp b/include/boost/pfr/detail/detectors.hpp
new file mode 100644
index 0000000000..2ee04e34a5
--- /dev/null
+++ b/include/boost/pfr/detail/detectors.hpp
@@ -0,0 +1,70 @@
+// Copyright (c) 2016-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_DETECTORS_HPP
+#define BOOST_PFR_DETAIL_DETECTORS_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <functional>
+#include <type_traits>
+
+namespace boost { namespace pfr { namespace detail {
+///////////////////// `value` is true if Detector<Tleft, Tright> does not compile (SFINAE)
+    struct can_not_apply{};
+
+    template <template <class, class> class Detector, class Tleft, class Tright>
+    struct not_appliable {
+        static constexpr bool value = std::is_same<
+            Detector<Tleft, Tright>,
+            can_not_apply
+        >::value;
+    };
+
+///////////////////// Detectors for different operators
+    template <class S, class T> auto comp_eq_detector_msvc_helper(long) -> decltype(std::declval<S>() == std::declval<T>());
+    template <class S, class T> can_not_apply comp_eq_detector_msvc_helper(int);
+    template <class T1, class T2> using comp_eq_detector = decltype(comp_eq_detector_msvc_helper<T1,T2>(1L));
+
+    template <class S, class T> auto comp_ne_detector_msvc_helper(long) -> decltype(std::declval<S>() != std::declval<T>());
+    template <class S, class T> can_not_apply comp_ne_detector_msvc_helper(int);
+    template <class T1, class T2> using comp_ne_detector = decltype(comp_ne_detector_msvc_helper<T1,T2>(1L));
+
+    template <class S, class T> auto comp_lt_detector_msvc_helper(long) -> decltype(std::declval<S>() < std::declval<T>());
+    template <class S, class T> can_not_apply comp_lt_detector_msvc_helper(int);
+    template <class T1, class T2> using comp_lt_detector = decltype(comp_lt_detector_msvc_helper<T1,T2>(1L));
+
+    template <class S, class T> auto comp_le_detector_msvc_helper(long) -> decltype(std::declval<S>() <= std::declval<T>());
+    template <class S, class T> can_not_apply comp_le_detector_msvc_helper(int);
+    template <class T1, class T2> using comp_le_detector = decltype(comp_le_detector_msvc_helper<T1,T2>(1L));
+
+    template <class S, class T> auto comp_gt_detector_msvc_helper(long) -> decltype(std::declval<S>() > std::declval<T>());
+    template <class S, class T> can_not_apply comp_gt_detector_msvc_helper(int);
+    template <class T1, class T2> using comp_gt_detector = decltype(comp_gt_detector_msvc_helper<T1,T2>(1L));
+
+    template <class S, class T> auto comp_ge_detector_msvc_helper(long) -> decltype(std::declval<S>() >= std::declval<T>());
+    template <class S, class T> can_not_apply comp_ge_detector_msvc_helper(int);
+    template <class T1, class T2> using comp_ge_detector = decltype(comp_ge_detector_msvc_helper<T1,T2>(1L));
+
+
+    template <class S> auto hash_detector_msvc_helper(long) -> decltype(std::hash<S>{}(std::declval<S>()));
+    template <class S> can_not_apply hash_detector_msvc_helper(int);
+    template <class T1, class T2> using hash_detector = decltype(hash_detector_msvc_helper<T1,T2>(1L));
+
+
+    template <class S, class T> auto ostreamable_detector_msvc_helper(long) -> decltype(std::declval<S>() << std::declval<T>());
+    template <class S, class T> can_not_apply ostreamable_detector_msvc_helper(int);
+    template <class S, class T> using ostreamable_detector = decltype(ostreamable_detector_msvc_helper<S,T>(1L));
+
+    template <class S, class T> auto istreamable_detector_msvc_helper(long) -> decltype(std::declval<S>() >> std::declval<T>());
+    template <class S, class T> can_not_apply istreamable_detector_msvc_helper(int);
+    template <class S, class T> using istreamable_detector = decltype(istreamable_detector_msvc_helper<S,T>(1L));
+
+}}} // namespace boost::pfr::detail
+
+#endif // BOOST_PFR_DETAIL_DETECTORS_HPP
+
+
diff --git a/include/boost/pfr/detail/fields_count.hpp b/include/boost/pfr/detail/fields_count.hpp
new file mode 100644
index 0000000000..bf7021ffe1
--- /dev/null
+++ b/include/boost/pfr/detail/fields_count.hpp
@@ -0,0 +1,262 @@
+// Copyright (c) 2016-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_FIELDS_COUNT_HPP
+#define BOOST_PFR_DETAIL_FIELDS_COUNT_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+#include <boost/pfr/detail/make_integer_sequence.hpp>
+#include <boost/pfr/detail/size_t_.hpp>
+#include <boost/pfr/detail/unsafe_declval.hpp>
+
+#include <climits>      // CHAR_BIT
+#include <type_traits>
+#include <utility>      // metaprogramming stuff
+
+#ifdef __clang__
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wmissing-braces"
+#   pragma clang diagnostic ignored "-Wundefined-inline"
+#   pragma clang diagnostic ignored "-Wundefined-internal"
+#   pragma clang diagnostic ignored "-Wmissing-field-initializers"
+#endif
+
+namespace boost { namespace pfr { namespace detail {
+
+///////////////////// Structure that can be converted to reference to anything
+struct ubiq_lref_constructor {
+    std::size_t ignore;
+    template <class Type> constexpr operator Type&() const && noexcept {  // Allows initialization of reference fields (T& and const T&)
+        return detail::unsafe_declval<Type&>();
+    };
+};
+
+///////////////////// Structure that can be converted to rvalue reference to anything
+struct ubiq_rref_constructor {
+    std::size_t ignore;
+    template <class Type> /*constexpr*/ operator Type&&() const && noexcept {  // Allows initialization of rvalue reference fields and move-only types
+        return detail::unsafe_declval<Type&&>();
+    };
+};
+
+
+#ifndef __cpp_lib_is_aggregate
+///////////////////// Hand-made is_aggregate_initializable_n<T> trait
+
+// Structure that can be converted to reference to anything except reference to T
+template <class T, bool IsCopyConstructible>
+struct ubiq_constructor_except {
+    std::size_t ignore;
+    template <class Type> constexpr operator std::enable_if_t<!std::is_same<T, Type>::value, Type&> () const noexcept; // Undefined
+};
+
+template <class T>
+struct ubiq_constructor_except<T, false> {
+    std::size_t ignore;
+    template <class Type> constexpr operator std::enable_if_t<!std::is_same<T, Type>::value, Type&&> () const noexcept; // Undefined
+};
+
+
+// `std::is_constructible<T, ubiq_constructor_except<T>>` consumes a lot of time, so we made a separate lazy trait for it.
+template <std::size_t N, class T> struct is_single_field_and_aggregate_initializable: std::false_type {};
+template <class T> struct is_single_field_and_aggregate_initializable<1, T>: std::integral_constant<
+    bool, !std::is_constructible<T, ubiq_constructor_except<T, std::is_copy_constructible<T>::value>>::value
+> {};
+
+// Hand-made is_aggregate<T> trait:
+// Before C++20 aggregates could be constructed from `decltype(ubiq_?ref_constructor{I})...` but type traits report that
+// there's no constructor from `decltype(ubiq_?ref_constructor{I})...`
+// Special case for N == 1: `std::is_constructible<T, ubiq_?ref_constructor>` returns true if N == 1 and T is copy/move constructible.
+template <class T, std::size_t N>
+struct is_aggregate_initializable_n {
+    template <std::size_t ...I>
+    static constexpr bool is_not_constructible_n(std::index_sequence<I...>) noexcept {
+        return (!std::is_constructible<T, decltype(ubiq_lref_constructor{I})...>::value && !std::is_constructible<T, decltype(ubiq_rref_constructor{I})...>::value)
+            || is_single_field_and_aggregate_initializable<N, T>::value
+        ;
+    }
+
+    static constexpr bool value =
+           std::is_empty<T>::value
+        || std::is_array<T>::value
+        || std::is_fundamental<T>::value
+        || is_not_constructible_n(detail::make_index_sequence<N>{})
+    ;
+};
+
+#endif // #ifndef __cpp_lib_is_aggregate
+
+///////////////////// Helper for SFINAE on fields count
+template <class T, std::size_t... I, class /*Enable*/ = typename std::enable_if<std::is_copy_constructible<T>::value>::type>
+constexpr auto enable_if_constructible_helper(std::index_sequence<I...>) noexcept
+    -> typename std::add_pointer<decltype(T{ ubiq_lref_constructor{I}... })>::type;
+
+template <class T, std::size_t... I, class /*Enable*/ = typename std::enable_if<!std::is_copy_constructible<T>::value>::type>
+constexpr auto enable_if_constructible_helper(std::index_sequence<I...>) noexcept
+    -> typename std::add_pointer<decltype(T{ ubiq_rref_constructor{I}... })>::type;
+
+template <class T, std::size_t N, class /*Enable*/ = decltype( enable_if_constructible_helper<T>(detail::make_index_sequence<N>()) ) >
+using enable_if_constructible_helper_t = std::size_t;
+
+///////////////////// Helpers for range size detection
+template <std::size_t Begin, std::size_t Last>
+using is_one_element_range = std::integral_constant<bool, Begin == Last>;
+
+using multi_element_range = std::false_type;
+using one_element_range = std::true_type;
+
+///////////////////// Non greedy fields count search. Templates instantiation depth is log(sizeof(T)), templates instantiation count is log(sizeof(T)).
+template <class T, std::size_t Begin, std::size_t Middle>
+constexpr std::size_t detect_fields_count(detail::one_element_range, long) noexcept {
+    static_assert(
+        Begin == Middle,
+        "====================> Boost.PFR: Internal logic error."
+    );
+    return Begin;
+}
+
+template <class T, std::size_t Begin, std::size_t Middle>
+constexpr std::size_t detect_fields_count(detail::multi_element_range, int) noexcept;
+
+template <class T, std::size_t Begin, std::size_t Middle>
+constexpr auto detect_fields_count(detail::multi_element_range, long) noexcept
+    -> detail::enable_if_constructible_helper_t<T, Middle>
+{
+    constexpr std::size_t next_v = Middle + (Middle - Begin + 1) / 2;
+    return detail::detect_fields_count<T, Middle, next_v>(detail::is_one_element_range<Middle, next_v>{}, 1L);
+}
+
+template <class T, std::size_t Begin, std::size_t Middle>
+constexpr std::size_t detect_fields_count(detail::multi_element_range, int) noexcept {
+    constexpr std::size_t next_v = Begin + (Middle - Begin) / 2;
+    return detail::detect_fields_count<T, Begin, next_v>(detail::is_one_element_range<Begin, next_v>{}, 1L);
+}
+
+///////////////////// Greedy search. Templates instantiation depth is log(sizeof(T)), templates instantiation count is log(sizeof(T))*T in worst case.
+template <class T, std::size_t N>
+constexpr auto detect_fields_count_greedy_remember(long) noexcept
+    -> detail::enable_if_constructible_helper_t<T, N>
+{
+    return N;
+}
+
+template <class T, std::size_t N>
+constexpr std::size_t detect_fields_count_greedy_remember(int) noexcept {
+    return 0;
+}
+
+template <class T, std::size_t Begin, std::size_t Last>
+constexpr std::size_t detect_fields_count_greedy(detail::one_element_range) noexcept {
+    static_assert(
+        Begin == Last,
+        "====================> Boost.PFR: Internal logic error."
+    );
+    return detail::detect_fields_count_greedy_remember<T, Begin>(1L);
+}
+
+template <class T, std::size_t Begin, std::size_t Last>
+constexpr std::size_t detect_fields_count_greedy(detail::multi_element_range) noexcept {
+    constexpr std::size_t middle = Begin + (Last - Begin) / 2;
+    constexpr std::size_t fields_count_big_range = detail::detect_fields_count_greedy<T, middle + 1, Last>(
+        detail::is_one_element_range<middle + 1, Last>{}
+    );
+
+    constexpr std::size_t small_range_begin = (fields_count_big_range ? 0 : Begin);
+    constexpr std::size_t small_range_last = (fields_count_big_range ? 0 : middle);
+    constexpr std::size_t fields_count_small_range = detail::detect_fields_count_greedy<T, small_range_begin, small_range_last>(
+        detail::is_one_element_range<small_range_begin, small_range_last>{}
+    );
+    return fields_count_big_range ? fields_count_big_range : fields_count_small_range;
+}
+
+///////////////////// Choosing between array size, greedy and non greedy search.
+template <class T, std::size_t N>
+constexpr auto detect_fields_count_dispatch(size_t_<N>, long, long) noexcept
+    -> typename std::enable_if<std::is_array<T>::value, std::size_t>::type
+{
+    return sizeof(T) / sizeof(typename std::remove_all_extents<T>::type);
+}
+
+template <class T, std::size_t N>
+constexpr auto detect_fields_count_dispatch(size_t_<N>, long, int) noexcept
+    -> decltype(sizeof(T{}))
+{
+    constexpr std::size_t middle = N / 2 + 1;
+    return detail::detect_fields_count<T, 0, middle>(detail::multi_element_range{}, 1L);
+}
+
+template <class T, std::size_t N>
+constexpr std::size_t detect_fields_count_dispatch(size_t_<N>, int, int) noexcept {
+    // T is not default aggregate initialzable. It means that at least one of the members is not default constructible,
+    // so we have to check all the aggregate initializations for T up to N parameters and return the bigest succeeded
+    // (we can not use binary search for detecting fields count).
+    return detail::detect_fields_count_greedy<T, 0, N>(detail::multi_element_range{});
+}
+
+///////////////////// Returns fields count
+template <class T>
+constexpr std::size_t fields_count() noexcept {
+    using type = std::remove_cv_t<T>;
+
+    static_assert(
+        !std::is_reference<type>::value,
+        "====================> Boost.PFR: Attempt to get fields count on a reference. This is not allowed because that could hide an issue and different library users expect different behavior in that case."
+    );
+
+    static_assert(
+        std::is_copy_constructible<std::remove_all_extents_t<type>>::value || (
+            std::is_move_constructible<std::remove_all_extents_t<type>>::value
+            && std::is_move_assignable<std::remove_all_extents_t<type>>::value
+        ),
+        "====================> Boost.PFR: Type and each field in the type must be copy constructible (or move constructible and move assignable)."
+    );
+
+    static_assert(
+        !std::is_polymorphic<type>::value,
+        "====================> Boost.PFR: Type must have no virtual function, because otherwise it is not aggregate initializable."
+    );
+
+#ifdef __cpp_lib_is_aggregate
+    static_assert(
+        std::is_aggregate<type>::value             // Does not return `true` for built-in types.
+        || std::is_scalar<type>::value,
+        "====================> Boost.PFR: Type must be aggregate initializable."
+    );
+#endif
+
+// Can't use the following. See the non_std_layout.cpp test.
+//#if !BOOST_PFR_USE_CPP17
+//    static_assert(
+//        std::is_standard_layout<type>::value,   // Does not return `true` for structs that have non standard layout members.
+//        "Type must be aggregate initializable."
+//    );
+//#endif
+
+    constexpr std::size_t max_fields_count = (sizeof(type) * CHAR_BIT); // We multiply by CHAR_BIT because the type may have bitfields in T
+    constexpr std::size_t result = detail::detect_fields_count_dispatch<type>(size_t_<max_fields_count>{}, 1L, 1L);
+
+#ifndef __cpp_lib_is_aggregate
+    static_assert(
+        is_aggregate_initializable_n<type, result>::value,
+        "====================> Boost.PFR: Types with user specified constructors (non-aggregate initializable types) are not supported."
+    );
+#endif
+
+    static_assert(
+        result != 0 || std::is_empty<type>::value || std::is_fundamental<type>::value || std::is_reference<type>::value,
+        "====================> Boost.PFR: If there's no other failed static asserts then something went wrong. Please report this issue to the github along with the structure you're reflecting."
+    );
+
+    return result;
+}
+
+}}} // namespace boost::pfr::detail
+
+#ifdef __clang__
+#   pragma clang diagnostic pop
+#endif
+
+#endif // BOOST_PFR_DETAIL_FIELDS_COUNT_HPP
diff --git a/include/boost/pfr/detail/for_each_field_impl.hpp b/include/boost/pfr/detail/for_each_field_impl.hpp
new file mode 100644
index 0000000000..64f5e63650
--- /dev/null
+++ b/include/boost/pfr/detail/for_each_field_impl.hpp
@@ -0,0 +1,54 @@
+// Copyright (c) 2016-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_FOR_EACH_FIELD_IMPL_HPP
+#define BOOST_PFR_DETAIL_FOR_EACH_FIELD_IMPL_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <utility>      // metaprogramming stuff
+
+#include <boost/pfr/detail/sequence_tuple.hpp>
+#include <boost/pfr/detail/rvalue_t.hpp>
+
+namespace boost { namespace pfr { namespace detail {
+
+template <std::size_t Index>
+using size_t_ = std::integral_constant<std::size_t, Index >;
+
+template <class T, class F, class I, class = decltype(std::declval<F>()(std::declval<T>(), I{}))>
+void for_each_field_impl_apply(T&& v, F&& f, I i, long) {
+    std::forward<F>(f)(std::forward<T>(v), i);
+}
+
+template <class T, class F, class I>
+void for_each_field_impl_apply(T&& v, F&& f, I /*i*/, int) {
+    std::forward<F>(f)(std::forward<T>(v));
+}
+
+template <class T, class F, std::size_t... I>
+void for_each_field_impl(T& t, F&& f, std::index_sequence<I...>, std::false_type /*move_values*/) {
+     const int v[] = {(
+         detail::for_each_field_impl_apply(sequence_tuple::get<I>(t), std::forward<F>(f), size_t_<I>{}, 1L),
+         0
+     )...};
+     (void)v;
+}
+
+
+template <class T, class F, std::size_t... I>
+void for_each_field_impl(T& t, F&& f, std::index_sequence<I...>, std::true_type /*move_values*/) {
+     const int v[] = {(
+         detail::for_each_field_impl_apply(sequence_tuple::get<I>(std::move(t)), std::forward<F>(f), size_t_<I>{}, 1L),
+         0
+     )...};
+     (void)v;
+}
+
+}}} // namespace boost::pfr::detail
+
+
+#endif // BOOST_PFR_DETAIL_FOR_EACH_FIELD_IMPL_HPP
diff --git a/include/boost/pfr/detail/functional.hpp b/include/boost/pfr/detail/functional.hpp
new file mode 100644
index 0000000000..dfd84971d3
--- /dev/null
+++ b/include/boost/pfr/detail/functional.hpp
@@ -0,0 +1,191 @@
+// Copyright (c) 2016-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_FUNCTIONAL_HPP
+#define BOOST_PFR_DETAIL_FUNCTIONAL_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <functional>
+
+#include <boost/pfr/detail/sequence_tuple.hpp>
+
+namespace boost { namespace pfr { namespace detail {
+    template <std::size_t I, std::size_t N>
+    struct equal_impl {
+        template <class T, class U>
+        constexpr static bool cmp(const T& v1, const U& v2) noexcept {
+            return ::boost::pfr::detail::sequence_tuple::get<I>(v1) == ::boost::pfr::detail::sequence_tuple::get<I>(v2)
+                && equal_impl<I + 1, N>::cmp(v1, v2);
+        }
+    };
+
+    template <std::size_t N>
+    struct equal_impl<N, N> {
+        template <class T, class U>
+        constexpr static bool cmp(const T&, const U&) noexcept {
+            return T::size_v == U::size_v;
+        }
+    };
+
+    template <std::size_t I, std::size_t N>
+    struct not_equal_impl {
+        template <class T, class U>
+        constexpr static bool cmp(const T& v1, const U& v2) noexcept {
+            return ::boost::pfr::detail::sequence_tuple::get<I>(v1) != ::boost::pfr::detail::sequence_tuple::get<I>(v2)
+                || not_equal_impl<I + 1, N>::cmp(v1, v2);
+        }
+    };
+
+    template <std::size_t N>
+    struct not_equal_impl<N, N> {
+        template <class T, class U>
+        constexpr static bool cmp(const T&, const U&) noexcept {
+            return T::size_v != U::size_v;
+        }
+    };
+
+    template <std::size_t I, std::size_t N>
+    struct less_impl {
+        template <class T, class U>
+        constexpr static bool cmp(const T& v1, const U& v2) noexcept {
+            return sequence_tuple::get<I>(v1) < sequence_tuple::get<I>(v2)
+                || (sequence_tuple::get<I>(v1) == sequence_tuple::get<I>(v2) && less_impl<I + 1, N>::cmp(v1, v2));
+        }
+    };
+
+    template <std::size_t N>
+    struct less_impl<N, N> {
+        template <class T, class U>
+        constexpr static bool cmp(const T&, const U&) noexcept {
+            return T::size_v < U::size_v;
+        }
+    };
+
+    template <std::size_t I, std::size_t N>
+    struct less_equal_impl {
+        template <class T, class U>
+        constexpr static bool cmp(const T& v1, const U& v2) noexcept {
+            return sequence_tuple::get<I>(v1) < sequence_tuple::get<I>(v2)
+                || (sequence_tuple::get<I>(v1) == sequence_tuple::get<I>(v2) && less_equal_impl<I + 1, N>::cmp(v1, v2));
+        }
+    };
+
+    template <std::size_t N>
+    struct less_equal_impl<N, N> {
+        template <class T, class U>
+        constexpr static bool cmp(const T&, const U&) noexcept {
+            return T::size_v <= U::size_v;
+        }
+    };
+
+    template <std::size_t I, std::size_t N>
+    struct greater_impl {
+        template <class T, class U>
+        constexpr static bool cmp(const T& v1, const U& v2) noexcept {
+            return sequence_tuple::get<I>(v1) > sequence_tuple::get<I>(v2)
+                || (sequence_tuple::get<I>(v1) == sequence_tuple::get<I>(v2) && greater_impl<I + 1, N>::cmp(v1, v2));
+        }
+    };
+
+    template <std::size_t N>
+    struct greater_impl<N, N> {
+        template <class T, class U>
+        constexpr static bool cmp(const T&, const U&) noexcept {
+            return T::size_v > U::size_v;
+        }
+    };
+
+    template <std::size_t I, std::size_t N>
+    struct greater_equal_impl {
+        template <class T, class U>
+        constexpr static bool cmp(const T& v1, const U& v2) noexcept {
+            return sequence_tuple::get<I>(v1) > sequence_tuple::get<I>(v2)
+                || (sequence_tuple::get<I>(v1) == sequence_tuple::get<I>(v2) && greater_equal_impl<I + 1, N>::cmp(v1, v2));
+        }
+    };
+
+    template <std::size_t N>
+    struct greater_equal_impl<N, N> {
+        template <class T, class U>
+        constexpr static bool cmp(const T&, const U&) noexcept {
+            return T::size_v >= U::size_v;
+        }
+    };
+
+    template <typename SizeT>
+    constexpr void hash_combine(SizeT& seed, SizeT value) noexcept {
+        seed ^= value + 0x9e3779b9 + (seed<<6) + (seed>>2);
+    }
+
+    template <typename T>
+    auto compute_hash(const T& value, long /*priority*/)
+        -> decltype(std::hash<T>()(value))
+    {
+        return std::hash<T>()(value);
+    }
+
+    template <typename T>
+    std::size_t compute_hash(const T& /*value*/, int /*priority*/) {
+        static_assert(sizeof(T) && false, "====================> Boost.PFR: std::hash not specialized for type T");
+        return 0;
+    }
+
+    template <std::size_t I, std::size_t N>
+    struct hash_impl {
+        template <class T>
+        constexpr static std::size_t compute(const T& val) noexcept {
+            std::size_t h = detail::compute_hash( ::boost::pfr::detail::sequence_tuple::get<I>(val), 1L );
+            detail::hash_combine(h, hash_impl<I + 1, N>::compute(val) );
+            return h;
+        }
+    };
+
+    template <std::size_t N>
+    struct hash_impl<N, N> {
+        template <class T>
+        constexpr static std::size_t compute(const T&) noexcept {
+            return 0;
+        }
+    };
+
+///////////////////// Define min_element and to avoid inclusion of <algorithm>
+    constexpr std::size_t min_size(std::size_t x, std::size_t y) noexcept {
+        return x < y ? x : y;
+    }
+
+    template <template <std::size_t, std::size_t> class Visitor, class T, class U>
+    bool binary_visit(const T& x, const U& y) {
+        constexpr std::size_t fields_count_lhs = detail::fields_count<std::remove_reference_t<T>>();
+        constexpr std::size_t fields_count_rhs = detail::fields_count<std::remove_reference_t<U>>();
+        constexpr std::size_t fields_count_min = detail::min_size(fields_count_lhs, fields_count_rhs);
+        typedef Visitor<0, fields_count_min> visitor_t;
+
+#if BOOST_PFR_USE_CPP17 || BOOST_PFR_USE_LOOPHOLE
+        return visitor_t::cmp(detail::tie_as_tuple(x), detail::tie_as_tuple(y));
+#else
+        bool result = true;
+        ::boost::pfr::detail::for_each_field_dispatcher(
+            x,
+            [&result, &y](const auto& lhs) {
+                ::boost::pfr::detail::for_each_field_dispatcher(
+                    y,
+                    [&result, &lhs](const auto& rhs) {
+                        result = visitor_t::cmp(lhs, rhs);
+                    },
+                    detail::make_index_sequence<fields_count_rhs>{}
+                );
+            },
+            detail::make_index_sequence<fields_count_lhs>{}
+        );
+
+        return result;
+#endif
+    }
+
+}}} // namespace boost::pfr::detail
+
+#endif // BOOST_PFR_DETAIL_FUNCTIONAL_HPP
diff --git a/include/boost/pfr/detail/io.hpp b/include/boost/pfr/detail/io.hpp
new file mode 100644
index 0000000000..9917e458f4
--- /dev/null
+++ b/include/boost/pfr/detail/io.hpp
@@ -0,0 +1,85 @@
+// Copyright (c) 2016-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_IO_HPP
+#define BOOST_PFR_DETAIL_IO_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <boost/pfr/detail/sequence_tuple.hpp>
+#include <iosfwd>       // stream operators
+#include <iomanip>
+
+#if defined(__has_include)
+#   if __has_include(<string_view>) && BOOST_PFR_USE_CPP17
+#       include <string_view>
+#   endif
+#endif
+
+namespace boost { namespace pfr { namespace detail {
+
+inline auto quoted_helper(const std::string& s) noexcept {
+    return std::quoted(s);
+}
+
+#if defined(__has_include)
+#   if __has_include(<string_view>) && BOOST_PFR_USE_CPP17
+template <class CharT, class Traits>
+inline auto quoted_helper(std::basic_string_view<CharT, Traits> s) noexcept {
+    return std::quoted(s);
+}
+#   endif
+#endif
+
+inline auto quoted_helper(std::string& s) noexcept {
+    return std::quoted(s);
+}
+
+template <class T>
+inline decltype(auto) quoted_helper(T&& v) noexcept {
+    return std::forward<T>(v);
+}
+
+template <std::size_t I, std::size_t N>
+struct print_impl {
+    template <class Stream, class T>
+    static void print (Stream& out, const T& value) {
+        if (!!I) out << ", ";
+        out << detail::quoted_helper(boost::pfr::detail::sequence_tuple::get<I>(value));
+        print_impl<I + 1, N>::print(out, value);
+    }
+};
+
+template <std::size_t I>
+struct print_impl<I, I> {
+    template <class Stream, class T> static void print (Stream&, const T&) noexcept {}
+};
+
+
+template <std::size_t I, std::size_t N>
+struct read_impl {
+    template <class Stream, class T>
+    static void read (Stream& in, const T& value) {
+        char ignore = {};
+        if (!!I) {
+            in >> ignore;
+            if (ignore != ',') in.setstate(Stream::failbit);
+            in >> ignore;
+            if (ignore != ' ')  in.setstate(Stream::failbit);
+        }
+        in >> detail::quoted_helper( boost::pfr::detail::sequence_tuple::get<I>(value) );
+        read_impl<I + 1, N>::read(in, value);
+    }
+};
+
+template <std::size_t I>
+struct read_impl<I, I> {
+    template <class Stream, class T> static void read (Stream&, const T&) {}
+};
+
+}}} // namespace boost::pfr::detail
+
+#endif // BOOST_PFR_DETAIL_IO_HPP
diff --git a/include/boost/pfr/detail/make_flat_tuple_of_references.hpp b/include/boost/pfr/detail/make_flat_tuple_of_references.hpp
new file mode 100644
index 0000000000..3c186cea2c
--- /dev/null
+++ b/include/boost/pfr/detail/make_flat_tuple_of_references.hpp
@@ -0,0 +1,96 @@
+// Copyright (c) 2016-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_MAKE_FLAT_TUPLE_OF_REFERENCES_HPP
+#define BOOST_PFR_DETAIL_MAKE_FLAT_TUPLE_OF_REFERENCES_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <utility>      // metaprogramming stuff
+#include <boost/pfr/detail/sequence_tuple.hpp>
+#include <boost/pfr/detail/rvalue_t.hpp>
+#include <boost/pfr/detail/make_integer_sequence.hpp>
+
+
+namespace boost { namespace pfr { namespace detail {
+
+template <std::size_t Index>
+using size_t_ = std::integral_constant<std::size_t, Index >;
+
+// Helper: Make a "getter" object corresponding to built-in tuple::get
+// For user-defined structures, the getter should be "offset_based_getter"
+struct sequence_tuple_getter {
+  template <std::size_t idx, typename TupleOfReferences>
+  decltype(auto) get(TupleOfReferences&& t, size_t_<idx>) const noexcept {
+    return sequence_tuple::get<idx>(std::forward<TupleOfReferences>(t));
+  }
+};
+
+
+template <class TupleOrUserType, class Getter, std::size_t Begin, std::size_t Size>
+constexpr auto make_flat_tuple_of_references(TupleOrUserType&, const Getter&, size_t_<Begin>, size_t_<Size>) noexcept;
+
+template <class TupleOrUserType, class Getter, std::size_t Begin>
+constexpr sequence_tuple::tuple<> make_flat_tuple_of_references(TupleOrUserType&, const Getter&, size_t_<Begin>, size_t_<0>) noexcept;
+
+template <class TupleOrUserType, class Getter, std::size_t Begin>
+constexpr auto make_flat_tuple_of_references(TupleOrUserType&, const Getter&, size_t_<Begin>, size_t_<1>) noexcept;
+
+template <class... T>
+constexpr auto tie_as_tuple_with_references(T&... args) noexcept {
+    return sequence_tuple::tuple<T&...>{ args... };
+}
+
+template <class... T>
+constexpr decltype(auto) tie_as_tuple_with_references(detail::sequence_tuple::tuple<T...>& t) noexcept {
+    return detail::make_flat_tuple_of_references(t, sequence_tuple_getter{}, size_t_<0>{}, size_t_<sequence_tuple::tuple<T...>::size_v>{});
+}
+
+template <class... T>
+constexpr decltype(auto) tie_as_tuple_with_references(const detail::sequence_tuple::tuple<T...>& t) noexcept {
+    return detail::make_flat_tuple_of_references(t, sequence_tuple_getter{}, size_t_<0>{}, size_t_<sequence_tuple::tuple<T...>::size_v>{});
+}
+
+template <class Tuple1, std::size_t... I1, class Tuple2, std::size_t... I2>
+constexpr auto my_tuple_cat_impl(const Tuple1& t1, std::index_sequence<I1...>, const Tuple2& t2, std::index_sequence<I2...>) noexcept {
+    return detail::tie_as_tuple_with_references(
+        sequence_tuple::get<I1>(t1)...,
+        sequence_tuple::get<I2>(t2)...
+    );
+}
+
+template <class Tuple1, class Tuple2>
+constexpr auto my_tuple_cat(const Tuple1& t1, const Tuple2& t2) noexcept {
+    return detail::my_tuple_cat_impl(
+        t1, detail::make_index_sequence< Tuple1::size_v >{},
+        t2, detail::make_index_sequence< Tuple2::size_v >{}
+    );
+}
+
+template <class TupleOrUserType, class Getter, std::size_t Begin, std::size_t Size>
+constexpr auto make_flat_tuple_of_references(TupleOrUserType& t, const Getter& g, size_t_<Begin>, size_t_<Size>) noexcept {
+    constexpr std::size_t next_size = Size / 2;
+    return detail::my_tuple_cat(
+        detail::make_flat_tuple_of_references(t, g, size_t_<Begin>{}, size_t_<next_size>{}),
+        detail::make_flat_tuple_of_references(t, g, size_t_<Begin + Size / 2>{}, size_t_<Size - next_size>{})
+    );
+}
+
+template <class TupleOrUserType, class Getter, std::size_t Begin>
+constexpr sequence_tuple::tuple<> make_flat_tuple_of_references(TupleOrUserType&, const Getter&, size_t_<Begin>, size_t_<0>) noexcept {
+    return {};
+}
+
+template <class TupleOrUserType, class Getter, std::size_t Begin>
+constexpr auto make_flat_tuple_of_references(TupleOrUserType& t, const Getter& g, size_t_<Begin>, size_t_<1>) noexcept {
+    return detail::tie_as_tuple_with_references(
+        g.get(t, size_t_<Begin>{})
+    );
+}
+
+}}} // namespace boost::pfr::detail
+
+#endif // BOOST_PFR_DETAIL_MAKE_FLAT_TUPLE_OF_REFERENCES_HPP
diff --git a/include/boost/pfr/detail/make_integer_sequence.hpp b/include/boost/pfr/detail/make_integer_sequence.hpp
new file mode 100644
index 0000000000..5474e230cb
--- /dev/null
+++ b/include/boost/pfr/detail/make_integer_sequence.hpp
@@ -0,0 +1,90 @@
+// Copyright (c) 2018 Sergei Fedorov
+// Copyright (c) 2019-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_MAKE_INTEGER_SEQUENCE_HPP
+#define BOOST_PFR_DETAIL_MAKE_INTEGER_SEQUENCE_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <type_traits>
+#include <utility>
+#include <cstddef>
+
+namespace boost { namespace pfr { namespace detail {
+
+#if BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE == 0
+
+#ifdef __has_builtin
+#   if __has_builtin(__make_integer_seq)
+#       define BOOST_PFR_USE_MAKE_INTEGER_SEQ_BUILTIN
+#   endif
+#endif
+
+#ifdef BOOST_PFR_USE_MAKE_INTEGER_SEQ_BUILTIN
+
+using std::integer_sequence;
+
+// Clang unable to use namespace qualified std::integer_sequence in __make_integer_seq.
+template <typename T, T N>
+using make_integer_sequence = __make_integer_seq<integer_sequence, T, N>;
+
+#undef BOOST_PFR_USE_MAKE_INTEGER_SEQ_BUILTIN
+
+#else
+
+template <typename T, typename U>
+struct join_sequences;
+
+template <typename T, T... A, T... B>
+struct join_sequences<std::integer_sequence<T, A...>, std::integer_sequence<T, B...>> {
+    using type = std::integer_sequence<T, A..., B...>;
+};
+
+template <typename T, T Min, T Max>
+struct build_sequence_impl {
+    static_assert(Min < Max, "Start of range must be less than its end");
+    static constexpr T size = Max - Min;
+    using type = typename join_sequences<
+            typename build_sequence_impl<T, Min, Min + size / 2>::type,
+            typename build_sequence_impl<T, Min + size / 2 + 1, Max>::type
+        >::type;
+};
+
+template <typename T, T V>
+struct build_sequence_impl<T, V, V> {
+    using type = std::integer_sequence<T, V>;
+};
+
+template <typename T, std::size_t N>
+struct make_integer_sequence_impl : build_sequence_impl<T, 0, N - 1> {};
+
+template <typename T>
+struct make_integer_sequence_impl<T, 0> {
+    using type = std::integer_sequence<T>;
+};
+
+template <typename T, T N>
+using make_integer_sequence = typename make_integer_sequence_impl<T, N>::type;
+
+#endif // !defined BOOST_PFR_USE_MAKE_INTEGER_SEQ_BUILTIN
+#else // BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE == 1
+
+template <typename T, T N>
+using make_integer_sequence = std::make_integer_sequence<T, N>;
+
+#endif // BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE == 1
+
+template <std::size_t N>
+using make_index_sequence = make_integer_sequence<std::size_t, N>;
+
+template <typename... T>
+using index_sequence_for = make_index_sequence<sizeof...(T)>;
+
+}}} // namespace boost::pfr::detail
+
+#endif
+
diff --git a/include/boost/pfr/detail/offset_based_getter.hpp b/include/boost/pfr/detail/offset_based_getter.hpp
new file mode 100644
index 0000000000..741f4c49e3
--- /dev/null
+++ b/include/boost/pfr/detail/offset_based_getter.hpp
@@ -0,0 +1,140 @@
+// Copyright (c) 2017-2018 Chris Beck
+// Copyright (c) 2019-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_OFFSET_BASED_GETTER_HPP
+#define BOOST_PFR_DETAIL_OFFSET_BASED_GETTER_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <type_traits>
+#include <utility>
+#include <boost/pfr/detail/sequence_tuple.hpp>
+#include <boost/pfr/detail/rvalue_t.hpp>
+#include <boost/pfr/detail/size_t_.hpp>
+
+
+namespace boost { namespace pfr { namespace detail {
+
+// Our own implementation of std::aligned_storage. On godbolt with MSVC, I have compilation errors
+// using the standard version, it seems the compiler cannot generate default ctor.
+
+template<std::size_t s, std::size_t a>
+struct internal_aligned_storage {
+   alignas(a) char storage_[s];
+};
+
+// Metafunction that replaces tuple<T1, T2, T3, ...> with
+// tuple<std::aligned_storage_t<sizeof(T1), alignof(T1)>, std::aligned_storage<sizeof(T2), alignof(T2)>, ...>
+//
+// The point is, the new tuple is "layout compatible" in the sense that members have the same offsets,
+// but this tuple is constexpr constructible.
+
+template <typename T>
+struct tuple_of_aligned_storage;
+
+template <typename... Ts>
+struct tuple_of_aligned_storage<sequence_tuple::tuple<Ts...>> {
+  using type = sequence_tuple::tuple<internal_aligned_storage<sizeof(Ts),
+#if defined(__GNUC__) && __GNUC__ < 8 && !defined(__x86_64__) && !defined(__CYGWIN__)
+      // Before GCC-8 the `alignof` was returning the optimal alignment rather than the minimal one.
+      // We have to adjust the alignemnt because otherwise we get the wrong offset.
+      (alignof(Ts) > 4 ? 4 : alignof(Ts))
+#else
+      alignof(Ts)
+#endif
+  >...>;
+};
+
+// Note: If pfr has a typelist also, could also have an overload for that here
+
+template <typename T>
+using tuple_of_aligned_storage_t = typename tuple_of_aligned_storage<T>::type;
+
+/***
+ * Given a structure type and its sequence of members, we want to build a function
+ * object "getter" that implements a version of `std::get` using offset arithmetic
+ * and reinterpret_cast.
+ *
+ * typename U should be a user-defined struct
+ * typename S should be a sequence_tuple which is layout compatible with U
+ */
+
+template <typename U, typename S>
+class offset_based_getter {
+  using this_t = offset_based_getter<U, S>;
+
+  static_assert(sizeof(U) == sizeof(S), "====================> Boost.PFR: Member sequence does not indicate correct size for struct type! Maybe the user-provided type is not a SimpleAggregate?");
+  static_assert(alignof(U) == alignof(S), "====================> Boost.PFR: Member sequence does not indicate correct alignment for struct type!");
+
+  static_assert(!std::is_const<U>::value, "====================> Boost.PFR: const should be stripped from user-defined type when using offset_based_getter or overload resolution will be ambiguous later, this indicates an error within pfr");
+  static_assert(!std::is_reference<U>::value, "====================> Boost.PFR: reference should be stripped from user-defined type when using offset_based_getter or overload resolution will be ambiguous later, this indicates an error within pfr");
+  static_assert(!std::is_volatile<U>::value, "====================> Boost.PFR: volatile should be stripped from user-defined type when using offset_based_getter or overload resolution will be ambiguous later. this indicates an error within pfr");
+
+  // Get type of idx'th member
+  template <std::size_t idx>
+  using index_t = typename sequence_tuple::tuple_element<idx, S>::type;
+
+  // Get offset of idx'th member
+  // Idea: Layout object has the same offsets as instance of S, so if S and U are layout compatible, then these offset
+  // calculations are correct.
+  template <std::size_t idx>
+  static constexpr std::ptrdiff_t offset() noexcept {
+    constexpr tuple_of_aligned_storage_t<S> layout{};
+    return &sequence_tuple::get<idx>(layout).storage_[0] - &sequence_tuple::get<0>(layout).storage_[0];
+  }
+
+  // Encapsulates offset arithmetic and reinterpret_cast
+  template <std::size_t idx>
+  static index_t<idx> * get_pointer(U * u) noexcept {
+    return reinterpret_cast<index_t<idx> *>(reinterpret_cast<char *>(u) + this_t::offset<idx>());
+  }
+
+  template <std::size_t idx>
+  static const index_t<idx> * get_pointer(const U * u) noexcept {
+    return reinterpret_cast<const index_t<idx> *>(reinterpret_cast<const char *>(u) + this_t::offset<idx>());
+  }
+
+  template <std::size_t idx>
+  static volatile index_t<idx> * get_pointer(volatile U * u) noexcept {
+    return reinterpret_cast<volatile index_t<idx> *>(reinterpret_cast<volatile char *>(u) + this_t::offset<idx>());
+  }
+
+  template <std::size_t idx>
+  static const volatile index_t<idx> * get_pointer(const volatile U * u) noexcept {
+    return reinterpret_cast<const volatile index_t<idx> *>(reinterpret_cast<const volatile char *>(u) + this_t::offset<idx>());
+  }
+
+public:
+  template <std::size_t idx>
+  index_t<idx> & get(U & u, size_t_<idx>) const noexcept {
+    return *this_t::get_pointer<idx>(std::addressof(u));
+  }
+
+  template <std::size_t idx>
+  index_t<idx> const & get(U const & u, size_t_<idx>) const noexcept {
+    return *this_t::get_pointer<idx>(std::addressof(u));
+  }
+
+  template <std::size_t idx>
+  index_t<idx> volatile & get(U volatile & u, size_t_<idx>) const noexcept {
+    return *this_t::get_pointer<idx>(std::addressof(u));
+  }
+
+  template <std::size_t idx>
+  index_t<idx> const volatile & get(U const volatile & u, size_t_<idx>) const noexcept {
+    return *this_t::get_pointer<idx>(std::addressof(u));
+  }
+
+  // rvalues must not be used here, to avoid template instantiation bloats.
+  template <std::size_t idx>
+  index_t<idx> && get(rvalue_t<U> u, size_t_<idx>) const = delete;
+};
+
+
+}}} // namespace boost::pfr::detail
+
+#endif // BOOST_PFR_DETAIL_OFFSET_LIST_HPP
diff --git a/include/boost/pfr/detail/rvalue_t.hpp b/include/boost/pfr/detail/rvalue_t.hpp
new file mode 100644
index 0000000000..9d3397b8b8
--- /dev/null
+++ b/include/boost/pfr/detail/rvalue_t.hpp
@@ -0,0 +1,35 @@
+// Copyright (c) 2016-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_RVALUE_T_HPP
+#define BOOST_PFR_DETAIL_RVALUE_T_HPP
+#pragma once
+
+#include <type_traits>
+#include <utility>      // std::enable_if_t
+
+// This header provides aliases rvalue_t and lvalue_t.
+//
+// Usage: template <class T> void foo(rvalue<T> rvalue);
+//
+// Those are useful for
+//  * better type safety - you can validate at compile time that only rvalue reference is passed into the function
+//  * documentation and readability - rvalue_t<T> is much better than T&&+SFINAE
+
+namespace boost { namespace pfr { namespace detail {
+
+/// Binds to rvalues only, no copying allowed.
+template <class T
+#ifdef BOOST_PFR_DETAIL_STRICT_RVALUE_TESTING
+    , class = std::enable_if_t<std::is_rvalue_reference<T&&>::value>
+#endif
+>
+using rvalue_t = T&&;
+
+/// Binds to mutable lvalues only
+
+}}} // namespace boost::pfr::detail
+
+#endif // BOOST_PFR_DETAIL_RVALUE_T_HPP
diff --git a/include/boost/pfr/detail/sequence_tuple.hpp b/include/boost/pfr/detail/sequence_tuple.hpp
new file mode 100644
index 0000000000..a875bdccc2
--- /dev/null
+++ b/include/boost/pfr/detail/sequence_tuple.hpp
@@ -0,0 +1,127 @@
+// Copyright (c) 2016-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_SEQUENCE_TUPLE_HPP
+#define BOOST_PFR_DETAIL_SEQUENCE_TUPLE_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+#include <boost/pfr/detail/make_integer_sequence.hpp>
+
+#include <utility>      // metaprogramming stuff
+#include <cstddef>      // std::size_t
+
+///////////////////// Tuple that holds its values in the supplied order
+namespace boost { namespace pfr { namespace detail { namespace sequence_tuple {
+
+template <std::size_t N, class T>
+struct base_from_member {
+    T value;
+};
+
+template <class I, class ...Tail>
+struct tuple_base;
+
+
+
+template <std::size_t... I, class ...Tail>
+struct tuple_base< std::index_sequence<I...>, Tail... >
+    : base_from_member<I , Tail>...
+{
+    static constexpr std::size_t size_v = sizeof...(I);
+
+    // We do not use `noexcept` in the following functions, because if user forget to put one then clang will issue an error:
+    // "error: exception specification of explicitly defaulted default constructor does not match the calculated one".
+    constexpr tuple_base() = default;
+    constexpr tuple_base(tuple_base&&) = default;
+    constexpr tuple_base(const tuple_base&) = default;
+
+    constexpr tuple_base(Tail... v) noexcept
+        : base_from_member<I, Tail>{ v }...
+    {}
+};
+
+template <>
+struct tuple_base<std::index_sequence<> > {
+    static constexpr std::size_t size_v = 0;
+};
+
+template <std::size_t N, class T>
+constexpr T& get_impl(base_from_member<N, T>& t) noexcept {
+    return t.value;
+}
+
+template <std::size_t N, class T>
+constexpr const T& get_impl(const base_from_member<N, T>& t) noexcept {
+    return t.value;
+}
+
+template <std::size_t N, class T>
+constexpr volatile T& get_impl(volatile base_from_member<N, T>& t) noexcept {
+    return t.value;
+}
+
+template <std::size_t N, class T>
+constexpr const volatile T& get_impl(const volatile base_from_member<N, T>& t) noexcept {
+    return t.value;
+}
+
+template <std::size_t N, class T>
+constexpr T&& get_impl(base_from_member<N, T>&& t) noexcept {
+    return std::forward<T>(t.value);
+}
+
+
+template <class ...Values>
+struct tuple: tuple_base<
+    detail::index_sequence_for<Values...>,
+    Values...>
+{
+    using tuple_base<
+        detail::index_sequence_for<Values...>,
+        Values...
+    >::tuple_base;
+};
+
+
+template <std::size_t N, class ...T>
+constexpr decltype(auto) get(tuple<T...>& t) noexcept {
+    static_assert(N < tuple<T...>::size_v, "====================> Boost.PFR: Tuple index out of bounds");
+    return sequence_tuple::get_impl<N>(t);
+}
+
+template <std::size_t N, class ...T>
+constexpr decltype(auto) get(const tuple<T...>& t) noexcept {
+    static_assert(N < tuple<T...>::size_v, "====================> Boost.PFR: Tuple index out of bounds");
+    return sequence_tuple::get_impl<N>(t);
+}
+
+template <std::size_t N, class ...T>
+constexpr decltype(auto) get(const volatile tuple<T...>& t) noexcept {
+    static_assert(N < tuple<T...>::size_v, "====================> Boost.PFR: Tuple index out of bounds");
+    return sequence_tuple::get_impl<N>(t);
+}
+
+template <std::size_t N, class ...T>
+constexpr decltype(auto) get(volatile tuple<T...>& t) noexcept {
+    static_assert(N < tuple<T...>::size_v, "====================> Boost.PFR: Tuple index out of bounds");
+    return sequence_tuple::get_impl<N>(t);
+}
+
+template <std::size_t N, class ...T>
+constexpr decltype(auto) get(tuple<T...>&& t) noexcept {
+    static_assert(N < tuple<T...>::size_v, "====================> Boost.PFR: Tuple index out of bounds");
+    return sequence_tuple::get_impl<N>(std::move(t));
+}
+
+template <std::size_t I, class T>
+using tuple_element = std::remove_reference< decltype(
+        ::boost::pfr::detail::sequence_tuple::get<I>( std::declval<T>() )
+    ) >;
+
+
+}}}} // namespace boost::pfr::detail::sequence_tuple
+
+#endif // BOOST_PFR_CORE_HPP
diff --git a/include/boost/pfr/detail/size_array.hpp b/include/boost/pfr/detail/size_array.hpp
new file mode 100644
index 0000000000..fc400234b9
--- /dev/null
+++ b/include/boost/pfr/detail/size_array.hpp
@@ -0,0 +1,79 @@
+// Copyright (c) 2016-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_SIZE_ARRAY_HPP
+#define BOOST_PFR_DETAIL_SIZE_ARRAY_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <cstddef>      // metaprogramming stuff
+
+namespace boost { namespace pfr { namespace detail {
+
+///////////////////// Array that has the constexpr
+template <std::size_t N>
+struct size_array {                         // libc++ misses constexpr on operator[]
+    typedef std::size_t type;
+    std::size_t data[N];
+
+    static constexpr std::size_t size() noexcept { return N; }
+
+    constexpr std::size_t count_nonzeros() const noexcept {
+        std::size_t count = 0;
+        for (std::size_t i = 0; i < size(); ++i) {
+            if (data[i]) {
+                ++ count;
+            }
+        }
+        return count;
+    }
+
+    constexpr std::size_t count_from_opening_till_matching_parenthis_seq(std::size_t from, std::size_t opening_parenthis, std::size_t closing_parenthis) const noexcept {
+        if (data[from] != opening_parenthis) {
+            return 0;
+        }
+        std::size_t unclosed_parnthesis = 0;
+        std::size_t count = 0;
+        for (; ; ++from) {
+            if (data[from] == opening_parenthis) {
+                ++ unclosed_parnthesis;
+            } else if (data[from] == closing_parenthis) {
+                -- unclosed_parnthesis;
+            }
+            ++ count;
+
+            if (unclosed_parnthesis == 0) {
+                return count;
+            }
+        }
+
+        return count;
+    }
+};
+
+template <>
+struct size_array<0> {                         // libc++ misses constexpr on operator[]
+    typedef std::size_t type;
+    std::size_t data[1];
+
+    static constexpr std::size_t size() noexcept { return 0; }
+
+    constexpr std::size_t count_nonzeros() const noexcept {
+        return 0;
+    }
+};
+
+template <std::size_t I, std::size_t N>
+constexpr std::size_t get(const size_array<N>& a) noexcept {
+    static_assert(I < N, "====================> Boost.PFR: Array index out of bounds");
+    return a.data[I];
+}
+
+
+
+}}} // namespace boost::pfr::detail
+
+#endif // BOOST_PFR_DETAIL_SIZE_ARRAY_HPP
diff --git a/include/boost/pfr/detail/size_t_.hpp b/include/boost/pfr/detail/size_t_.hpp
new file mode 100644
index 0000000000..134d2ee64d
--- /dev/null
+++ b/include/boost/pfr/detail/size_t_.hpp
@@ -0,0 +1,18 @@
+// Copyright (c) 2016-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_SIZE_T_HPP
+#define BOOST_PFR_DETAIL_SIZE_T_HPP
+#pragma once
+
+namespace boost { namespace pfr { namespace detail {
+
+///////////////////// General utility stuff
+template <std::size_t Index>
+using size_t_ = std::integral_constant<std::size_t, Index >;
+
+}}} // namespace boost::pfr::detail
+
+#endif // BOOST_PFR_DETAIL_SIZE_T_HPP
diff --git a/include/boost/pfr/detail/stdtuple.hpp b/include/boost/pfr/detail/stdtuple.hpp
new file mode 100644
index 0000000000..84d0a999cf
--- /dev/null
+++ b/include/boost/pfr/detail/stdtuple.hpp
@@ -0,0 +1,46 @@
+// Copyright (c) 2016-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_STDTUPLE_HPP
+#define BOOST_PFR_DETAIL_STDTUPLE_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <utility>      // metaprogramming stuff
+#include <tuple>
+
+#include <boost/pfr/detail/sequence_tuple.hpp>
+
+namespace boost { namespace pfr { namespace detail {
+
+template <class T, std::size_t... I>
+constexpr auto make_stdtuple_from_tietuple(const T& t, std::index_sequence<I...>) noexcept {
+    return std::make_tuple(
+        boost::pfr::detail::sequence_tuple::get<I>(t)...
+    );
+}
+
+template <class T, std::size_t... I>
+constexpr auto make_stdtiedtuple_from_tietuple(const T& t, std::index_sequence<I...>) noexcept {
+    return std::tie(
+        boost::pfr::detail::sequence_tuple::get<I>(t)...
+    );
+}
+
+template <class T, std::size_t... I>
+constexpr auto make_conststdtiedtuple_from_tietuple(const T& t, std::index_sequence<I...>) noexcept {
+    return std::tuple<
+        std::add_lvalue_reference_t<std::add_const_t<
+            std::remove_reference_t<decltype(boost::pfr::detail::sequence_tuple::get<I>(t))>
+        >>...
+    >(
+        boost::pfr::detail::sequence_tuple::get<I>(t)...
+    );
+}
+
+}}} // namespace boost::pfr::detail
+
+#endif // BOOST_PFR_DETAIL_STDTUPLE_HPP
diff --git a/include/boost/pfr/detail/tie_from_structure_tuple.hpp b/include/boost/pfr/detail/tie_from_structure_tuple.hpp
new file mode 100644
index 0000000000..d446037226
--- /dev/null
+++ b/include/boost/pfr/detail/tie_from_structure_tuple.hpp
@@ -0,0 +1,44 @@
+// Copyright (c) 2018 Adam Butcher, Antony Polukhin
+// Copyright (c) 2019-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_TIE_FROM_STRUCTURE_TUPLE_HPP
+#define BOOST_PFR_DETAIL_TIE_FROM_STRUCTURE_TUPLE_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <boost/pfr/detail/core.hpp>
+
+#include <boost/pfr/detail/stdtuple.hpp>
+#include <boost/pfr/tuple_size.hpp>
+#include <boost/pfr/detail/make_integer_sequence.hpp>
+
+#include <tuple>
+
+namespace boost { namespace pfr { namespace detail {
+
+/// \brief A `std::tuple` capable of de-structuring assignment used to support
+/// a tie of multiple lvalue references to fields of an aggregate T.
+///
+/// \sa boost::pfr::tie_from_structure
+template <typename... Elements>
+struct tie_from_structure_tuple : std::tuple<Elements&...> {
+    using base = std::tuple<Elements&...>;
+    using base::base;
+
+    template <typename T>
+    constexpr tie_from_structure_tuple& operator= (T const& t) {
+        base::operator=(
+            detail::make_stdtiedtuple_from_tietuple(
+                detail::tie_as_tuple(t),
+                detail::make_index_sequence<tuple_size_v<T>>()));
+        return *this;
+    }
+};
+
+}}} // boost::pfr::detail
+
+#endif // BOOST_PFR_DETAIL_TIE_FROM_STRUCTURE_TUPLE_HPP
diff --git a/include/boost/pfr/detail/unsafe_declval.hpp b/include/boost/pfr/detail/unsafe_declval.hpp
new file mode 100644
index 0000000000..f95f5a2372
--- /dev/null
+++ b/include/boost/pfr/detail/unsafe_declval.hpp
@@ -0,0 +1,36 @@
+// Copyright (c) 2019-2020 Antony Polukhin.
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_UNSAFE_DECLVAL_HPP
+#define BOOST_PFR_DETAIL_UNSAFE_DECLVAL_HPP
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <type_traits>
+
+namespace boost { namespace pfr { namespace detail {
+
+// This function serves as a link-time assert. If linker requires it, then
+// `unsafe_declval()` is used at runtime.
+void report_if_you_see_link_error_with_this_function() noexcept;
+
+// For returning non default constructible types. Do NOT use at runtime!
+//
+// GCCs std::declval may not be used in potentionally evaluated contexts,
+// so we reinvent it.
+template <class T>
+constexpr T unsafe_declval() noexcept {
+    report_if_you_see_link_error_with_this_function();
+
+    typename std::remove_reference<T>::type* ptr = 0;
+    ptr += 42; // suppresses 'null pointer dereference' warnings
+    return static_cast<T>(*ptr);
+}
+
+}}} // namespace boost::pfr::detail
+
+
+#endif // BOOST_PFR_DETAIL_UNSAFE_DECLVAL_HPP
+
diff --git a/include/boost/pfr/functions_for.hpp b/include/boost/pfr/functions_for.hpp
new file mode 100644
index 0000000000..3071d36d97
--- /dev/null
+++ b/include/boost/pfr/functions_for.hpp
@@ -0,0 +1,93 @@
+// Copyright (c) 2016-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_FUNCTIONS_FOR_HPP
+#define BOOST_PFR_FUNCTIONS_FOR_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <boost/pfr/ops_fields.hpp>
+#include <boost/pfr/io_fields.hpp>
+
+/// \file boost/pfr/functions_for.hpp
+/// Contains BOOST_PFR_FUNCTIONS_FOR macro that defined comparison and stream operators for T along with hash_value function.
+/// \b Example:
+/// \code
+///     #include <boost/pfr/functions_for.hpp>
+///
+///     namespace my_namespace {
+///         struct my_struct {      // No operators defined for that structure
+///             int i; short s; char data[7]; bool bl; int a,b,c,d,e,f;
+///         };
+///         BOOST_PFR_FUNCTIONS_FOR(my_struct)
+///     }
+/// \endcode
+///
+/// \podops for other ways to define operators and more details.
+///
+/// \b Synopsis:
+
+/// \def BOOST_PFR_FUNCTIONS_FOR(T)
+/// Defines comparison and stream operators for T along with hash_value function.
+///
+/// \b Example:
+/// \code
+///     #include <boost/pfr/functions_for.hpp>
+///     struct comparable_struct {      // No operators defined for that structure
+///         int i; short s; char data[7]; bool bl; int a,b,c,d,e,f;
+///     };
+///     BOOST_PFR_FUNCTIONS_FOR(comparable_struct)
+///     // ...
+///
+///     comparable_struct s1 {0, 1, "Hello", false, 6,7,8,9,10,11};
+///     comparable_struct s2 {0, 1, "Hello", false, 6,7,8,9,10,11111};
+///     assert(s1 < s2);
+///     std::cout << s1 << std::endl; // Outputs: {0, 1, H, e, l, l, o, , , 0, 6, 7, 8, 9, 10, 11}
+/// \endcode
+///
+/// \podops for other ways to define operators and more details.
+///
+/// \b Defines \b following \b for \b T:
+/// \code
+/// bool operator==(const T& lhs, const T& rhs);
+/// bool operator!=(const T& lhs, const T& rhs);
+/// bool operator< (const T& lhs, const T& rhs);
+/// bool operator> (const T& lhs, const T& rhs);
+/// bool operator<=(const T& lhs, const T& rhs);
+/// bool operator>=(const T& lhs, const T& rhs);
+///
+/// template <class Char, class Traits>
+/// std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& out, const T& value);
+///
+/// template <class Char, class Traits>
+/// std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& in, T& value);
+///
+/// // helper function for Boost unordered containers and boost::hash<>.
+/// std::size_t hash_value(const T& value);
+/// \endcode
+
+#define BOOST_PFR_FUNCTIONS_FOR(T)                                                                                                          \
+    BOOST_PFR_MAYBE_UNUSED inline bool operator==(const T& lhs, const T& rhs) { return ::boost::pfr::eq_fields(lhs, rhs); }                 \
+    BOOST_PFR_MAYBE_UNUSED inline bool operator!=(const T& lhs, const T& rhs) { return ::boost::pfr::ne_fields(lhs, rhs); }                 \
+    BOOST_PFR_MAYBE_UNUSED inline bool operator< (const T& lhs, const T& rhs) { return ::boost::pfr::lt_fields(lhs, rhs); }                 \
+    BOOST_PFR_MAYBE_UNUSED inline bool operator> (const T& lhs, const T& rhs) { return ::boost::pfr::gt_fields(lhs, rhs); }                 \
+    BOOST_PFR_MAYBE_UNUSED inline bool operator<=(const T& lhs, const T& rhs) { return ::boost::pfr::le_fields(lhs, rhs); }                 \
+    BOOST_PFR_MAYBE_UNUSED inline bool operator>=(const T& lhs, const T& rhs) { return ::boost::pfr::ge_fields(lhs, rhs); }                 \
+    template <class Char, class Traits>                                                                                                     \
+    BOOST_PFR_MAYBE_UNUSED inline ::std::basic_ostream<Char, Traits>& operator<<(::std::basic_ostream<Char, Traits>& out, const T& value) { \
+        return out << ::boost::pfr::io_fields(value);                                                                                       \
+    }                                                                                                                                       \
+    template <class Char, class Traits>                                                                                                     \
+    BOOST_PFR_MAYBE_UNUSED inline ::std::basic_istream<Char, Traits>& operator>>(::std::basic_istream<Char, Traits>& in, T& value) {        \
+        return in >> ::boost::pfr::io_fields(value);                                                                                        \
+    }                                                                                                                                       \
+    BOOST_PFR_MAYBE_UNUSED inline std::size_t hash_value(const T& v) {                                                                      \
+        return ::boost::pfr::hash_fields(v);                                                                                                \
+    }                                                                                                                                       \
+/**/
+
+#endif // BOOST_PFR_FUNCTIONS_FOR_HPP
+
diff --git a/include/boost/pfr/functors.hpp b/include/boost/pfr/functors.hpp
new file mode 100644
index 0000000000..dbd7a78c65
--- /dev/null
+++ b/include/boost/pfr/functors.hpp
@@ -0,0 +1,221 @@
+// Copyright (c) 2016-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_FUNCTORS_HPP
+#define BOOST_PFR_FUNCTORS_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <boost/pfr/ops.hpp>
+
+#include <boost/pfr/detail/functional.hpp>
+
+/// \file boost/pfr/functors.hpp
+/// Contains functors that are close to the Standard Library ones.
+/// Each functor calls corresponding Boost.PFR function from boost/pfr/ops.hpp
+///
+/// \b Example:
+/// \code
+///     #include <boost/pfr/functors.hpp>
+///     struct my_struct {      // No operators defined for that structure
+///         int i; short s; char data[7]; bool bl; int a,b,c,d,e,f;
+///     };
+///     // ...
+///
+///     std::unordered_set<
+///         my_struct,
+///         boost::pfr::hash<>,
+///         boost::pfr::equal_to<>
+///     > my_set;
+/// \endcode
+///
+/// \b Synopsis:
+namespace boost { namespace pfr {
+
+///////////////////// Comparisons
+
+/// \brief std::equal_to like comparator that returns \forcedlink{eq}(x, y)
+template <class T = void> struct equal_to {
+    /// \return \b true if each field of \b x equals the field with same index of \b y.
+    bool operator()(const T& x, const T& y) const {
+        return boost::pfr::eq(x, y);
+    }
+
+#ifdef BOOST_PFR_DOXYGEN_INVOKED
+    /// This typedef exists only if T \b is void
+    typedef std::true_type is_transparent;
+
+    /// This operator allows comparison of \b x and \b y that have different type.
+    /// \pre Exists only if T \b is void.
+    template <class V, class U> bool operator()(const V& x, const U& y) const;
+#endif
+};
+
+/// @cond
+template <> struct equal_to<void> {
+    template <class T, class U>
+    bool operator()(const T& x, const U& y) const {
+        return boost::pfr::eq(x, y);
+    }
+
+    typedef std::true_type is_transparent;
+};
+/// @endcond
+
+/// \brief std::not_equal like comparator that returns \forcedlink{ne}(x, y)
+template <class T = void> struct not_equal {
+    /// \return \b true if at least one field \b x not equals the field with same index of \b y.
+    bool operator()(const T& x, const T& y) const {
+        return boost::pfr::ne(x, y);
+    }
+
+#ifdef BOOST_PFR_DOXYGEN_INVOKED
+    /// This typedef exists only if T \b is void
+    typedef std::true_type is_transparent;
+
+    /// This operator allows comparison of \b x and \b y that have different type.
+    /// \pre Exists only if T \b is void.
+    template <class V, class U> bool operator()(const V& x, const U& y) const;
+#endif
+};
+
+/// @cond
+template <> struct not_equal<void> {
+    template <class T, class U>
+    bool operator()(const T& x, const U& y) const {
+        return boost::pfr::ne(x, y);
+    }
+
+    typedef std::true_type is_transparent;
+};
+/// @endcond
+
+/// \brief std::greater like comparator that returns \forcedlink{gt}(x, y)
+template <class T = void> struct greater {
+    /// \return \b true if field of \b x greater than the field with same index of \b y and all previous fields of \b x equal to the same fields of \b y.
+    bool operator()(const T& x, const T& y) const {
+        return boost::pfr::gt(x, y);
+    }
+
+#ifdef BOOST_PFR_DOXYGEN_INVOKED
+    /// This typedef exists only if T \b is void
+    typedef std::true_type is_transparent;
+
+    /// This operator allows comparison of \b x and \b y that have different type.
+    /// \pre Exists only if T \b is void.
+    template <class V, class U> bool operator()(const V& x, const U& y) const;
+#endif
+};
+
+/// @cond
+template <> struct greater<void> {
+    template <class T, class U>
+    bool operator()(const T& x, const U& y) const {
+        return boost::pfr::gt(x, y);
+    }
+
+    typedef std::true_type is_transparent;
+};
+/// @endcond
+
+/// \brief std::less like comparator that returns \forcedlink{lt}(x, y)
+template <class T = void> struct less {
+    /// \return \b true if field of \b x less than the field with same index of \b y and all previous fields of \b x equal to the same fields of \b y.
+    bool operator()(const T& x, const T& y) const {
+        return boost::pfr::lt(x, y);
+    }
+
+#ifdef BOOST_PFR_DOXYGEN_INVOKED
+    /// This typedef exists only if T \b is void
+    typedef std::true_type is_transparent;
+
+    /// This operator allows comparison of \b x and \b y that have different type.
+    /// \pre Exists only if T \b is void.
+    template <class V, class U> bool operator()(const V& x, const U& y) const;
+#endif
+};
+
+/// @cond
+template <> struct less<void> {
+    template <class T, class U>
+    bool operator()(const T& x, const U& y) const {
+        return boost::pfr::lt(x, y);
+    }
+
+    typedef std::true_type is_transparent;
+};
+/// @endcond
+
+/// \brief std::greater_equal like comparator that returns \forcedlink{ge}(x, y)
+template <class T = void> struct greater_equal {
+    /// \return \b true if field of \b x greater than the field with same index of \b y and all previous fields of \b x equal to the same fields of \b y;
+    /// or if each field of \b x equals the field with same index of \b y.
+    bool operator()(const T& x, const T& y) const {
+        return boost::pfr::ge(x, y);
+    }
+
+#ifdef BOOST_PFR_DOXYGEN_INVOKED
+    /// This typedef exists only if T \b is void
+    typedef std::true_type is_transparent;
+
+    /// This operator allows comparison of \b x and \b y that have different type.
+    /// \pre Exists only if T \b is void.
+    template <class V, class U> bool operator()(const V& x, const U& y) const;
+#endif
+};
+
+/// @cond
+template <> struct greater_equal<void> {
+    template <class T, class U>
+    bool operator()(const T& x, const U& y) const {
+        return boost::pfr::ge(x, y);
+    }
+
+    typedef std::true_type is_transparent;
+};
+/// @endcond
+
+/// \brief std::less_equal like comparator that returns \forcedlink{le}(x, y)
+template <class T = void> struct less_equal {
+    /// \return \b true if field of \b x less than the field with same index of \b y and all previous fields of \b x equal to the same fields of \b y;
+    /// or if each field of \b x equals the field with same index of \b y.
+    bool operator()(const T& x, const T& y) const {
+        return boost::pfr::le(x, y);
+    }
+
+#ifdef BOOST_PFR_DOXYGEN_INVOKED
+    /// This typedef exists only if T \b is void
+    typedef std::true_type is_transparent;
+
+    /// This operator allows comparison of \b x and \b y that have different type.
+    /// \pre Exists only if T \b is void.
+    template <class V, class U> bool operator()(const V& x, const U& y) const;
+#endif
+};
+
+/// @cond
+template <> struct less_equal<void> {
+    template <class T, class U>
+    bool operator()(const T& x, const U& y) const {
+        return boost::pfr::le(x, y);
+    }
+
+    typedef std::true_type is_transparent;
+};
+/// @endcond
+
+
+/// \brief std::hash like functor that returns \forcedlink{hash_value}(x)
+template <class T> struct hash {
+    /// \return hash value of \b x.
+    std::size_t operator()(const T& x) const {
+        return boost::pfr::hash_value(x);
+    }
+};
+
+}} // namespace boost::pfr
+
+#endif // BOOST_PFR_FUNCTORS_HPP
diff --git a/include/boost/pfr/io.hpp b/include/boost/pfr/io.hpp
new file mode 100644
index 0000000000..29763f881f
--- /dev/null
+++ b/include/boost/pfr/io.hpp
@@ -0,0 +1,113 @@
+// Copyright (c) 2016-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_IO_HPP
+#define BOOST_PFR_IO_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <boost/pfr/detail/detectors.hpp>
+#include <boost/pfr/io_fields.hpp>
+
+/// \file boost/pfr/io.hpp
+/// Contains IO stream manipulator \forcedlink{io} for types.
+/// If type is streamable using its own operator or its conversion operator, then the types operator is used.
+///
+/// \b Example:
+/// \code
+///     #include <boost/pfr/io.hpp>
+///     struct comparable_struct {      // No operators defined for that structure
+///         int i; short s; char data[7]; bool bl; int a,b,c,d,e,f;
+///     };
+///     // ...
+///
+///     comparable_struct s1 {0, 1, "Hello", false, 6,7,8,9,10,11};
+///     std::cout << boost::pfr::io(s1);  // Outputs: {0, 1, H, e, l, l, o, , , 0, 6, 7, 8, 9, 10, 11}
+/// \endcode
+///
+/// \podops for other ways to define operators and more details.
+///
+/// \b Synopsis:
+namespace boost { namespace pfr {
+
+namespace detail {
+
+///////////////////// Helper typedefs
+    template <class Stream, class Type>
+    using enable_not_ostreamable_t = std::enable_if_t<
+        not_appliable<ostreamable_detector, Stream&, const std::remove_reference_t<Type>&>::value,
+        Stream&
+    >;
+
+    template <class Stream, class Type>
+    using enable_not_istreamable_t = std::enable_if_t<
+        not_appliable<istreamable_detector, Stream&, Type&>::value,
+        Stream&
+    >;
+
+    template <class Stream, class Type>
+    using enable_ostreamable_t = std::enable_if_t<
+        !not_appliable<ostreamable_detector, Stream&, const std::remove_reference_t<Type>&>::value,
+        Stream&
+    >;
+
+    template <class Stream, class Type>
+    using enable_istreamable_t = std::enable_if_t<
+        !not_appliable<istreamable_detector, Stream&, Type&>::value,
+        Stream&
+    >;
+
+///////////////////// IO impl
+
+template <class T>
+struct io_impl {
+    T value;
+};
+
+template <class Char, class Traits, class T>
+enable_not_ostreamable_t<std::basic_ostream<Char, Traits>, T> operator<<(std::basic_ostream<Char, Traits>& out, io_impl<T>&& x) {
+    return out << boost::pfr::io_fields(std::forward<T>(x.value));
+}
+
+template <class Char, class Traits, class T>
+enable_ostreamable_t<std::basic_ostream<Char, Traits>, T> operator<<(std::basic_ostream<Char, Traits>& out, io_impl<T>&& x) {
+    return out << x.value;
+}
+
+template <class Char, class Traits, class T>
+enable_not_istreamable_t<std::basic_istream<Char, Traits>, T> operator>>(std::basic_istream<Char, Traits>& in, io_impl<T>&& x) {
+    return in >> boost::pfr::io_fields(std::forward<T>(x.value));
+}
+
+template <class Char, class Traits, class T>
+enable_istreamable_t<std::basic_istream<Char, Traits>, T> operator>>(std::basic_istream<Char, Traits>& in, io_impl<T>&& x) {
+    return in >> x.value;
+}
+
+} // namespace detail
+
+/// IO manupulator to read/write \aggregate `value` using its IO stream operators or using \forcedlink{io_fields} if operators are not awailable.
+///
+/// \b Example:
+/// \code
+///     struct my_struct { int i; short s; };
+///     my_struct s;
+///     std::stringstream ss;
+///     ss << "{ 12, 13 }";
+///     ss >> boost::pfr::io(s);
+///     assert(s.i == 12);
+///     assert(s.i == 13);
+/// \endcode
+///
+/// \customio
+template <class T>
+auto io(T&& value) noexcept {
+    return detail::io_impl<T>{std::forward<T>(value)};
+}
+
+}} // namespace boost::pfr
+
+#endif // BOOST_PFR_IO_HPP
diff --git a/include/boost/pfr/io_fields.hpp b/include/boost/pfr/io_fields.hpp
new file mode 100644
index 0000000000..0388fc8e42
--- /dev/null
+++ b/include/boost/pfr/io_fields.hpp
@@ -0,0 +1,164 @@
+// Copyright (c) 2016-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+#ifndef BOOST_PFR_IO_FIELDS_HPP
+#define BOOST_PFR_IO_FIELDS_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <boost/pfr/detail/core.hpp>
+
+#include <type_traits>
+#include <utility>      // metaprogramming stuff
+
+#include <boost/pfr/detail/sequence_tuple.hpp>
+#include <boost/pfr/detail/io.hpp>
+#include <boost/pfr/detail/make_integer_sequence.hpp>
+#include <boost/pfr/tuple_size.hpp>
+
+/// \file boost/pfr/io_fields.hpp
+/// Contains IO manupulator \forcedlink{io_fields} to read/write \aggregate `value` field-by-field.
+///
+/// \b Example:
+/// \code
+///     struct my_struct {
+///         int i;
+///         short s;
+///     };
+///
+///     std::ostream& operator<<(std::ostream& os, const my_struct& x) {
+///         return os << boost::pfr::io_fields(x);  // Equivalent to: os << "{ " << x.i << " ," <<  x.s << " }"
+///     }
+///
+///     std::istream& operator>>(std::istream& is, my_struct& x) {
+///         return is >> boost::pfr::io_fields(x);  // Equivalent to: is >> "{ " >> x.i >> " ," >>  x.s >> " }"
+///     }
+/// \endcode
+///
+/// \podops for other ways to define operators and more details.
+///
+/// \b Synopsis:
+
+namespace boost { namespace pfr {
+
+namespace detail {
+
+template <class T>
+struct io_fields_impl {
+    T value;
+};
+
+
+template <class Char, class Traits, class T>
+std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& out, io_fields_impl<const T&>&& x) {
+    const T& value = x.value;
+    constexpr std::size_t fields_count_val = boost::pfr::detail::fields_count<T>();
+    out << '{';
+#if BOOST_PFR_USE_CPP17 || BOOST_PFR_USE_LOOPHOLE
+    detail::print_impl<0, fields_count_val>::print(out, detail::tie_as_tuple(value));
+#else
+    ::boost::pfr::detail::for_each_field_dispatcher(
+        value,
+        [&out](const auto& val) {
+            // We can not reuse `fields_count_val` in lambda because compilers had issues with
+            // passing constexpr variables into lambdas. Computing is again is the most portable solution.
+            constexpr std::size_t fields_count_val_lambda = boost::pfr::detail::fields_count<T>();
+            detail::print_impl<0, fields_count_val_lambda>::print(out, val);
+        },
+        detail::make_index_sequence<fields_count_val>{}
+    );
+#endif
+    return out << '}';
+}
+
+
+template <class Char, class Traits, class T>
+std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& out, io_fields_impl<T>&& x) {
+    return out << io_fields_impl<const std::remove_reference_t<T>&>{x.value};
+}
+
+template <class Char, class Traits, class T>
+std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& in, io_fields_impl<T&>&& x) {
+    T& value = x.value;
+    constexpr std::size_t fields_count_val = boost::pfr::detail::fields_count<T>();
+
+    const auto prev_exceptions = in.exceptions();
+    in.exceptions( typename std::basic_istream<Char, Traits>::iostate(0) );
+    const auto prev_flags = in.flags( typename std::basic_istream<Char, Traits>::fmtflags(0) );
+
+    char parenthis = {};
+    in >> parenthis;
+    if (parenthis != '{') in.setstate(std::basic_istream<Char, Traits>::failbit);
+
+#if BOOST_PFR_USE_CPP17 || BOOST_PFR_USE_LOOPHOLE
+    detail::read_impl<0, fields_count_val>::read(in, detail::tie_as_tuple(value));
+#else
+    ::boost::pfr::detail::for_each_field_dispatcher(
+        value,
+        [&in](const auto& val) {
+            // We can not reuse `fields_count_val` in lambda because compilers had issues with
+            // passing constexpr variables into lambdas. Computing is again is the most portable solution.
+            constexpr std::size_t fields_count_val_lambda = boost::pfr::detail::fields_count<T>();
+            detail::read_impl<0, fields_count_val_lambda>::read(in, val);
+        },
+        detail::make_index_sequence<fields_count_val>{}
+    );
+#endif
+
+    in >> parenthis;
+    if (parenthis != '}') in.setstate(std::basic_istream<Char, Traits>::failbit);
+
+    in.flags(prev_flags);
+    in.exceptions(prev_exceptions);
+
+    return in;
+}
+
+template <class Char, class Traits, class T>
+std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& in, io_fields_impl<const T&>&& ) {
+    static_assert(sizeof(T) && false, "====================> Boost.PFR: Atetmpt to use istream operator on a boost::pfr::io_fields wrapped type T with const qualifier.");
+    return in;
+}
+
+template <class Char, class Traits, class T>
+std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& in, io_fields_impl<T>&& ) {
+    static_assert(sizeof(T) && false, "====================> Boost.PFR: Atetmpt to use istream operator on a boost::pfr::io_fields wrapped temporary of type T.");
+    return in;
+}
+
+} // namespace detail
+
+/// IO manupulator to read/write \aggregate `value` field-by-field.
+///
+/// \b Example:
+/// \code
+///     struct my_struct {
+///         int i;
+///         short s;
+///     };
+///
+///     std::ostream& operator<<(std::ostream& os, const my_struct& x) {
+///         return os << boost::pfr::io_fields(x);  // Equivalent to: os << "{ " << x.i << " ," <<  x.s << " }"
+///     }
+///
+///     std::istream& operator>>(std::istream& is, my_struct& x) {
+///         return is >> boost::pfr::io_fields(x);  // Equivalent to: is >> "{ " >> x.i >> " ," >>  x.s >> " }"
+///     }
+/// \endcode
+///
+/// Input and output streaming operators for `boost::pfr::io_fields` are symmetric, meaning that you get the original value by streaming it and
+/// reading back if each fields streaming operator is symmetric.
+///
+/// \customio
+template <class T>
+auto io_fields(T&& value) noexcept {
+    return detail::io_fields_impl<T>{std::forward<T>(value)};
+}
+
+}} // namespace boost::pfr
+
+#endif // BOOST_PFR_IO_FIELDS_HPP
diff --git a/include/boost/pfr/ops.hpp b/include/boost/pfr/ops.hpp
new file mode 100644
index 0000000000..005a85ebe3
--- /dev/null
+++ b/include/boost/pfr/ops.hpp
@@ -0,0 +1,187 @@
+// Copyright (c) 2016-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_OPS_HPP
+#define BOOST_PFR_OPS_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <boost/pfr/detail/detectors.hpp>
+#include <boost/pfr/ops_fields.hpp>
+
+/// \file boost/pfr/ops.hpp
+/// Contains comparison and hashing functions.
+/// If type is comparable using its own operator or its conversion operator, then the types operator is used. Otherwise
+/// the operation is done via corresponding function from boost/pfr/ops.hpp header.
+///
+/// \b Example:
+/// \code
+///     #include <boost/pfr/ops.hpp>
+///     struct comparable_struct {      // No operators defined for that structure
+///         int i; short s; char data[7]; bool bl; int a,b,c,d,e,f;
+///     };
+///     // ...
+///
+///     comparable_struct s1 {0, 1, "Hello", false, 6,7,8,9,10,11};
+///     comparable_struct s2 {0, 1, "Hello", false, 6,7,8,9,10,11111};
+///     assert(boost::pfr::lt(s1, s2));
+/// \endcode
+///
+/// \podops for other ways to define operators and more details.
+///
+/// \b Synopsis:
+namespace boost { namespace pfr {
+
+namespace detail {
+
+///////////////////// Helper typedefs that are used by all the ops
+    template <template <class, class> class Detector, class T, class U>
+    using enable_not_comp_base_t = std::enable_if_t<
+        not_appliable<Detector, T const&, U const&>::value,
+        bool
+    >;
+
+    template <template <class, class> class Detector, class T, class U>
+    using enable_comp_base_t = std::enable_if_t<
+        !not_appliable<Detector, T const&, U const&>::value,
+        bool
+    >;
+///////////////////// std::enable_if_t like functions that enable only if types do not support operation
+
+    template <class T, class U> using enable_not_eq_comp_t = enable_not_comp_base_t<comp_eq_detector, T, U>;
+    template <class T, class U> using enable_not_ne_comp_t = enable_not_comp_base_t<comp_ne_detector, T, U>;
+    template <class T, class U> using enable_not_lt_comp_t = enable_not_comp_base_t<comp_lt_detector, T, U>;
+    template <class T, class U> using enable_not_le_comp_t = enable_not_comp_base_t<comp_le_detector, T, U>;
+    template <class T, class U> using enable_not_gt_comp_t = enable_not_comp_base_t<comp_gt_detector, T, U>;
+    template <class T, class U> using enable_not_ge_comp_t = enable_not_comp_base_t<comp_ge_detector, T, U>;
+
+    template <class T> using enable_not_hashable_t = std::enable_if_t<
+        not_appliable<hash_detector, const T&, const T&>::value,
+        std::size_t
+    >;
+///////////////////// std::enable_if_t like functions that enable only if types do support operation
+
+    template <class T, class U> using enable_eq_comp_t = enable_comp_base_t<comp_eq_detector, T, U>;
+    template <class T, class U> using enable_ne_comp_t = enable_comp_base_t<comp_ne_detector, T, U>;
+    template <class T, class U> using enable_lt_comp_t = enable_comp_base_t<comp_lt_detector, T, U>;
+    template <class T, class U> using enable_le_comp_t = enable_comp_base_t<comp_le_detector, T, U>;
+    template <class T, class U> using enable_gt_comp_t = enable_comp_base_t<comp_gt_detector, T, U>;
+    template <class T, class U> using enable_ge_comp_t = enable_comp_base_t<comp_ge_detector, T, U>;
+
+    template <class T> using enable_hashable_t = std::enable_if_t<
+        !not_appliable<hash_detector, const T&, const T&>::value,
+        std::size_t
+    >;
+} // namespace detail
+
+
+/// \brief Compares lhs and rhs for equality using their own comparison and conversion operators; if no operators avalable returns \forcedlink{eq_fields}(lhs, rhs).
+///
+/// \returns true if lhs is equal to rhs; false otherwise
+template <class T, class U>
+detail::enable_not_eq_comp_t<T, U> eq(const T& lhs, const U& rhs) noexcept {
+    return boost::pfr::eq_fields(lhs, rhs);
+}
+
+/// \overload eq
+template <class T, class U>
+detail::enable_eq_comp_t<T, U> eq(const T& lhs, const U& rhs) {
+    return lhs == rhs;
+}
+
+
+/// \brief Compares lhs and rhs for inequality using their own comparison and conversion operators; if no operators avalable returns \forcedlink{ne_fields}(lhs, rhs).
+///
+/// \returns true if lhs is not equal to rhs; false otherwise
+template <class T, class U>
+detail::enable_not_ne_comp_t<T, U> ne(const T& lhs, const U& rhs) noexcept {
+    return boost::pfr::ne_fields(lhs, rhs);
+}
+
+/// \overload ne
+template <class T, class U>
+detail::enable_ne_comp_t<T, U> ne(const T& lhs, const U& rhs) {
+    return lhs != rhs;
+}
+
+
+/// \brief Compares lhs and rhs for less-than using their own comparison and conversion operators; if no operators avalable returns \forcedlink{lt_fields}(lhs, rhs).
+///
+/// \returns true if lhs is less than rhs; false otherwise
+template <class T, class U>
+detail::enable_not_lt_comp_t<T, U> lt(const T& lhs, const U& rhs) noexcept {
+    return boost::pfr::lt_fields(lhs, rhs);
+}
+
+/// \overload lt
+template <class T, class U>
+detail::enable_lt_comp_t<T, U> lt(const T& lhs, const U& rhs) {
+    return lhs < rhs;
+}
+
+
+/// \brief Compares lhs and rhs for greater-than using their own comparison and conversion operators; if no operators avalable returns \forcedlink{lt_fields}(lhs, rhs).
+///
+/// \returns true if lhs is greater than rhs; false otherwise
+template <class T, class U>
+detail::enable_not_gt_comp_t<T, U> gt(const T& lhs, const U& rhs) noexcept {
+    return boost::pfr::gt_fields(lhs, rhs);
+}
+
+/// \overload gt
+template <class T, class U>
+detail::enable_gt_comp_t<T, U> gt(const T& lhs, const U& rhs) {
+    return lhs > rhs;
+}
+
+
+/// \brief Compares lhs and rhs for less-equal using their own comparison and conversion operators; if no operators avalable returns \forcedlink{le_fields}(lhs, rhs).
+///
+/// \returns true if lhs is less or equal to rhs; false otherwise
+template <class T, class U>
+detail::enable_not_le_comp_t<T, U> le(const T& lhs, const U& rhs) noexcept {
+    return boost::pfr::le_fields(lhs, rhs);
+}
+
+/// \overload le
+template <class T, class U>
+detail::enable_le_comp_t<T, U> le(const T& lhs, const U& rhs) {
+    return lhs <= rhs;
+}
+
+
+/// \brief Compares lhs and rhs for greater-equal using their own comparison and conversion operators; if no operators avalable returns \forcedlink{ge_fields}(lhs, rhs).
+///
+/// \returns true if lhs is greater or equal to rhs; false otherwise
+template <class T, class U>
+detail::enable_not_ge_comp_t<T, U> ge(const T& lhs, const U& rhs) noexcept {
+    return boost::pfr::ge_fields(lhs, rhs);
+}
+
+/// \overload ge
+template <class T, class U>
+detail::enable_ge_comp_t<T, U> ge(const T& lhs, const U& rhs) {
+    return lhs >= rhs;
+}
+
+
+/// \brief Hashes value using its own std::hash specialization; if no std::hash specialization avalable returns \forcedlink{hash_fields}(value).
+///
+/// \returns std::size_t with hash of the value
+template <class T>
+detail::enable_not_hashable_t<T> hash_value(const T& value) noexcept {
+    return boost::pfr::hash_fields(value);
+}
+
+/// \overload hash_value
+template <class T>
+detail::enable_hashable_t<T> hash_value(const T& value) {
+    return std::hash<T>{}(value);
+}
+
+}} // namespace boost::pfr
+
+#endif // BOOST_PFR_OPS_HPP
diff --git a/include/boost/pfr/ops_fields.hpp b/include/boost/pfr/ops_fields.hpp
new file mode 100644
index 0000000000..b9f1567a93
--- /dev/null
+++ b/include/boost/pfr/ops_fields.hpp
@@ -0,0 +1,127 @@
+// Copyright (c) 2016-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_OPS_FIELDS_HPP
+#define BOOST_PFR_OPS_FIELDS_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <boost/pfr/core.hpp>
+#include <boost/pfr/detail/functional.hpp>
+
+/// \file boost/pfr/ops_fields.hpp
+/// Contains field-by-fields comparison and hash functions.
+///
+/// \b Example:
+/// \code
+///     #include <boost/pfr/ops_fields.hpp>
+///     struct comparable_struct {      // No operators defined for that structure
+///         int i; short s;
+///     };
+///     // ...
+///
+///     comparable_struct s1 {0, 1};
+///     comparable_struct s2 {0, 2};
+///     assert(boost::pfr::lt_fields(s1, s2));
+/// \endcode
+///
+/// \podops for other ways to define operators and more details.
+///
+/// \b Synopsis:
+namespace boost { namespace pfr {
+
+    /// Does a field-by-field equality comparison.
+    ///
+    /// \returns `L == R && tuple_size_v<T> == tuple_size_v<U>`, where `L` and
+    /// `R` are the results of calling `std::tie` on first `N` fields of `lhs` and
+    // `rhs` respectively; `N` is `std::min(tuple_size_v<T>, tuple_size_v<U>)`.
+    template <class T, class U>
+    bool eq_fields(const T& lhs, const U& rhs) noexcept {
+        return detail::binary_visit<detail::equal_impl>(lhs, rhs);
+    }
+
+
+    /// Does a field-by-field inequality comparison.
+    ///
+    /// \returns `L != R || tuple_size_v<T> != tuple_size_v<U>`, where `L` and
+    /// `R` are the results of calling `std::tie` on first `N` fields of `lhs` and
+    // `rhs` respectively; `N` is `std::min(tuple_size_v<T>, tuple_size_v<U>)`.
+    template <class T, class U>
+    bool ne_fields(const T& lhs, const U& rhs) noexcept {
+        return detail::binary_visit<detail::not_equal_impl>(lhs, rhs);
+    }
+
+    /// Does a field-by-field greter comparison.
+    ///
+    /// \returns `L > R || (L == R && tuple_size_v<T> > tuple_size_v<U>)`, where `L` and
+    /// `R` are the results of calling `std::tie` on first `N` fields of `lhs` and
+    // `rhs` respectively; `N` is `std::min(tuple_size_v<T>, tuple_size_v<U>)`.
+    template <class T, class U>
+    bool gt_fields(const T& lhs, const U& rhs) noexcept {
+        return detail::binary_visit<detail::greater_impl>(lhs, rhs);
+    }
+
+
+    /// Does a field-by-field less comparison.
+    ///
+    /// \returns `L < R || (L == R && tuple_size_v<T> < tuple_size_v<U>)`, where `L` and
+    /// `R` are the results of calling `std::tie` on first `N` fields of `lhs` and
+    // `rhs` respectively; `N` is `std::min(tuple_size_v<T>, tuple_size_v<U>)`.
+    template <class T, class U>
+    bool lt_fields(const T& lhs, const U& rhs) noexcept {
+        return detail::binary_visit<detail::less_impl>(lhs, rhs);
+    }
+
+
+    /// Does a field-by-field greater equal comparison.
+    ///
+    /// \returns `L > R || (L == R && tuple_size_v<T> >= tuple_size_v<U>)`, where `L` and
+    /// `R` are the results of calling `std::tie` on first `N` fields of `lhs` and
+    // `rhs` respectively; `N` is `std::min(tuple_size_v<T>, tuple_size_v<U>)`.
+    template <class T, class U>
+    bool ge_fields(const T& lhs, const U& rhs) noexcept {
+        return detail::binary_visit<detail::greater_equal_impl>(lhs, rhs);
+    }
+
+
+    /// Does a field-by-field less equal comparison.
+    ///
+    /// \returns `L < R || (L == R && tuple_size_v<T> <= tuple_size_v<U>)`, where `L` and
+    /// `R` are the results of calling `std::tie` on first `N` fields of `lhs` and
+    // `rhs` respectively; `N` is `std::min(tuple_size_v<T>, tuple_size_v<U>)`.
+    template <class T, class U>
+    bool le_fields(const T& lhs, const U& rhs) noexcept {
+        return detail::binary_visit<detail::less_equal_impl>(lhs, rhs);
+    }
+
+
+    /// Does a field-by-field hashing.
+    ///
+    /// \returns combined hash of all the fields
+    template <class T>
+    std::size_t hash_fields(const T& x) {
+        constexpr std::size_t fields_count_val = boost::pfr::detail::fields_count<std::remove_reference_t<T>>();
+#if BOOST_PFR_USE_CPP17 || BOOST_PFR_USE_LOOPHOLE
+        return detail::hash_impl<0, fields_count_val>::compute(detail::tie_as_tuple(x));
+#else
+        std::size_t result = 0;
+        ::boost::pfr::detail::for_each_field_dispatcher(
+            x,
+            [&result](const auto& lhs) {
+                // We can not reuse `fields_count_val` in lambda because compilers had issues with
+                // passing constexpr variables into lambdas. Computing is again is the most portable solution.
+                constexpr std::size_t fields_count_val_lambda = boost::pfr::detail::fields_count<std::remove_reference_t<T>>();
+                result = detail::hash_impl<0, fields_count_val_lambda>::compute(lhs);
+            },
+            detail::make_index_sequence<fields_count_val>{}
+        );
+
+        return result;
+#endif
+    }
+}} // namespace boost::pfr
+
+#endif // BOOST_PFR_OPS_HPP
diff --git a/include/boost/pfr/tuple_size.hpp b/include/boost/pfr/tuple_size.hpp
new file mode 100644
index 0000000000..e201abb853
--- /dev/null
+++ b/include/boost/pfr/tuple_size.hpp
@@ -0,0 +1,48 @@
+// Copyright (c) 2016-2020 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+#ifndef BOOST_PFR_TUPLE_SIZE_HPP
+#define BOOST_PFR_TUPLE_SIZE_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <type_traits>
+#include <utility>      // metaprogramming stuff
+
+#include <boost/pfr/detail/sequence_tuple.hpp>
+#include <boost/pfr/detail/fields_count.hpp>
+
+/// \file boost/pfr/tuple_size.hpp
+/// Contains tuple-like interfaces to get fields count \forcedlink{tuple_size}, \forcedlink{tuple_size_v}.
+///
+/// \b Synopsis:
+namespace boost { namespace pfr {
+
+/// Has a static const member variable `value` that contains fields count in a T.
+/// Works for any T that supports aggregate initialization.
+///
+/// \b Example:
+/// \code
+///     std::array<int, boost::pfr::tuple_size<my_structure>::value > a;
+/// \endcode
+template <class T>
+using tuple_size = detail::size_t_< boost::pfr::detail::fields_count<T>() >;
+
+
+/// `tuple_size_v` is a template variable that contains fields count in a T and
+/// works for any T that supports aggregate initialization.
+///
+/// \b Example:
+/// \code
+///     std::array<int, boost::pfr::tuple_size_v<my_structure> > a;
+/// \endcode
+template <class T>
+constexpr std::size_t tuple_size_v = tuple_size<T>::value;
+
+}} // namespace boost::pfr
+
+#endif // BOOST_PFR_TUPLE_SIZE_HPP
diff --git a/include/llama/View.hpp b/include/llama/View.hpp
index 978469aae6..59c5bec5c1 100644
--- a/include/llama/View.hpp
+++ b/include/llama/View.hpp
@@ -10,6 +10,7 @@
 #include "macros.hpp"
 #include "mapping/One.hpp"
 
+#include <boost/pfr.hpp>
 #include <boost/preprocessor/cat.hpp>
 #include <type_traits>
 
@@ -60,7 +61,8 @@ namespace llama
     LLAMA_FN_HOST_ACC_INLINE auto allocViewStack() -> decltype(auto)
     {
         using Mapping = llama::mapping::One<ArrayDomain<Dim>, DatumDomain>;
-        return allocView(Mapping{}, llama::allocator::Stack<sizeOf<DatumDomain>>{});
+        using MadeDatumDomain = mapping::MakeDatumDomain<DatumDomain>; // user might pass struct to reflect
+        return allocView(Mapping{}, llama::allocator::Stack<sizeOf<MadeDatumDomain>>{});
     }
 
     template <typename View, typename BoundDatumDomain = DatumCoord<>, bool OwnView = false>
@@ -258,18 +260,50 @@ namespace llama
         template <typename... Ts>
         constexpr inline auto dependentFalse = false;
 
+        template <typename T>
+        constexpr inline auto tupleish_size = []() constexpr
+        {
+            if constexpr (isTupleLike<T>)
+                return std::tuple_size_v<T>;
+            else if constexpr (std::is_aggregate_v<T>) // TODO
+                return boost::pfr::tuple_size_v<T>;
+            else
+                static_assert(
+                    dependentFalse<T>,
+                    "T is not a tuple like type or an aggregate to reflect with boost.pfr");
+        }
+        ();
+
+        template <std::size_t I, typename T>
+        decltype(auto) tupleish_get(T&& t)
+        {
+            using DT = std::decay_t<T>;
+            if constexpr (isTupleLike<DT>)
+            {
+                using std::get;
+                return get<I>(std::forward<T>(t));
+            }
+            else if constexpr (std::is_aggregate_v<DT>) // TODO
+                return boost::pfr::get<I>(std::forward<T>(t));
+            else
+                static_assert(
+                    dependentFalse<T>,
+                    "T is not a tuple like type or an aggregate to reflect with boost.pfr");
+        }
+
         template <typename Tuple1, typename Tuple2, std::size_t... Is>
         LLAMA_FN_HOST_ACC_INLINE void assignTuples(Tuple1&& dst, Tuple2&& src, std::index_sequence<Is...>);
 
         template <typename T1, typename T2>
         LLAMA_FN_HOST_ACC_INLINE void assignTupleElement(T1&& dst, T2&& src)
         {
-            if constexpr (isTupleLike<std::decay_t<T1>> && isTupleLike<std::decay_t<T2>>)
-            {
-                static_assert(std::tuple_size_v<std::decay_t<T1>> == std::tuple_size_v<std::decay_t<T2>>);
-                assignTuples(dst, src, std::make_index_sequence<std::tuple_size_v<std::decay_t<T1>>>{});
-            }
-            else if constexpr (!isTupleLike<std::decay_t<T1>> && !isTupleLike<std::decay_t<T2>>)
+            using DT1 = std::decay_t<T1>;
+            using DT2 = std::decay_t<T2>;
+            constexpr auto isTupleish1 = isTupleLike<DT1> || std::is_aggregate_v<DT1>;
+            constexpr auto isTupleish2 = isTupleLike<DT2> || std::is_aggregate_v<DT2>;
+            if constexpr (isTupleish1 && isTupleish2)
+                assignTuples(dst, src, std::make_index_sequence<tupleish_size<DT1>>{});
+            else if constexpr (!isTupleish1 && !isTupleish2)
                 std::forward<T1>(dst) = std::forward<T2>(src);
             else
                 static_assert(dependentFalse<T1, T2>, "Elements to assign are not tuple/tuple or non-tuple/non-tuple.");
@@ -278,9 +312,11 @@ namespace llama
         template <typename Tuple1, typename Tuple2, std::size_t... Is>
         LLAMA_FN_HOST_ACC_INLINE void assignTuples(Tuple1&& dst, Tuple2&& src, std::index_sequence<Is...>)
         {
-            static_assert(std::tuple_size_v<std::decay_t<Tuple1>> == std::tuple_size_v<std::decay_t<Tuple2>>);
-            using std::get;
-            (assignTupleElement(get<Is>(std::forward<Tuple1>(dst)), get<Is>(std::forward<Tuple2>(src))), ...);
+            static_assert(tupleish_size<std::decay_t<Tuple1>> == tupleish_size<std::decay_t<Tuple2>>);
+            (assignTupleElement(
+                 tupleish_get<Is>(std::forward<Tuple1>(dst)),
+                 tupleish_get<Is>(std::forward<Tuple2>(src))),
+             ...);
         }
 
         template <typename T, typename Tuple, std::size_t... Is>
@@ -306,8 +342,53 @@ namespace llama
         template <typename T, template <typename...> typename Tuple, typename... Args>
         constexpr inline auto
             isDirectListInitializableFromTuple<T, Tuple<Args...>> = isDirectListInitializable<T, Args...>;
+
+        template <typename Tuplish, typename Coord>
+        struct GetNestedTuplishType;
+
+        template <typename Tuplish, std::size_t Head, std::size_t... Tail>
+        struct GetNestedTuplishType<Tuplish, DatumCoord<Head, Tail...>>
+        {
+            using type = typename GetNestedTuplishType<
+                std::decay_t<decltype(tupleish_get<Head>(std::declval<Tuplish>()))>,
+                DatumCoord<Tail...>>::type;
+        };
+
+        template <typename Tuplish>
+        struct GetNestedTuplishType<Tuplish, DatumCoord<>>
+        {
+            using type = Tuplish;
+        };
+
+        template <typename OriginalDatumDomain, typename BoundDatumDomain>
+        struct GetValueStructOrVoid
+        {
+            using type = typename internal::GetNestedTuplishType<OriginalDatumDomain, BoundDatumDomain>::type;
+        };
+
+        template <typename... Elements, typename BoundDatumDomain>
+        struct GetValueStructOrVoid<DatumStruct<Elements...>, BoundDatumDomain>
+        {
+            using type = void;
+        };
     } // namespace internal
 
+    template <typename T>
+    struct IndirectValue
+    {
+        T value;
+
+        auto operator->() -> T*
+        {
+            return &value;
+        }
+
+        auto operator->() const -> const T*
+        {
+            return &value;
+        }
+    };
+
     /// Virtual data type returned by \ref View after resolving a user domain
     /// coordinate or partially resolving a \ref DatumCoord. A virtual datum
     /// does not hold data itself (thus named "virtual"), it just binds enough
@@ -323,6 +404,8 @@ namespace llama
     private:
         using ArrayDomain = typename View::Mapping::ArrayDomain;
         using DatumDomain = typename View::Mapping::DatumDomain;
+        using ValueStruct = typename internal::
+            GetValueStructOrVoid<typename View::Mapping::OriginalDatumDomain, BoundDatumDomain>::type;
 
         const ArrayDomain userDomainPos;
         std::conditional_t<OwnView, View, View&> view;
@@ -333,10 +416,12 @@ namespace llama
         /// AccessibleDatumDomain is the same as `Mapping::DatumDomain`.
         using AccessibleDatumDomain = GetType<DatumDomain, BoundDatumDomain>;
 
+        static constexpr auto supportsValueLoad = !std::is_void_v<ValueStruct>;
+
         LLAMA_FN_HOST_ACC_INLINE VirtualDatum()
             /* requires(OwnView) */
             : userDomainPos({})
-            , view{allocViewStack<1, DatumDomain>()}
+            , view{allocViewStack<1, std::conditional_t<supportsValueLoad, ValueStruct, DatumDomain>>()}
         {
             static_assert(OwnView, "The default constructor of VirtualDatum is only available if the ");
         }
@@ -417,10 +502,31 @@ namespace llama
             return this->operator=<VirtualDatum>(other);
         }
 
+    private:
+        template <typename T>
+        struct ConvertibleTo
+        {
+            template <typename U>
+            using fn = std::is_convertible<T, U>;
+        };
+
+    public:
+        // TODO: this operator does too much black magic already
         template <typename T>
         LLAMA_FN_HOST_ACC_INLINE auto operator=(const T& other) -> VirtualDatum&
         {
-            return internal::virtualDatumArithOperator<internal::Assign>(*this, other);
+            if constexpr (
+                is_VirtualDatum<
+                    T> || boost::mp11::mp_any_of_q<FlattenDatumDomain<AccessibleDatumDomain>, ConvertibleTo<T>>::value)
+                return internal::virtualDatumArithOperator<internal::Assign>(*this, other);
+            else
+            {
+                internal::assignTuples(
+                    asTuple(),
+                    other,
+                    std::make_index_sequence<std::tuple_size_v<decltype(asTuple())>>{});
+                return *this;
+            }
         }
 
         template <typename T>
@@ -623,42 +729,30 @@ namespace llama
                 std::make_index_sequence<std::tuple_size_v<decltype(asFlatTuple())>>{});
         }
 
-        struct Loader
-        {
-            VirtualDatum& vd;
-
-            template <typename T>
-            operator T()
-            {
-                return vd.loadAs<T>();
-            }
-        };
-
-        struct LoaderConst
+        template <typename T>
+        operator T()
         {
-            const VirtualDatum& vd;
-
-            template <typename T>
-            operator T() const
-            {
-                return vd.loadAs<T>();
-            }
-        };
+            return loadAs<T>();
+        }
 
-        auto load() -> Loader
+        template <typename T>
+        operator T() const
         {
-            return {*this};
+            return loadAs<T>();
         }
 
-        auto load() const -> LoaderConst
+        // template <typename = std::enable_if_t<supportsValueLoad>>
+        auto operator->() const -> IndirectValue<ValueStruct>
         {
-            return {*this};
+            static_assert(supportsValueLoad);
+            return {loadAs<ValueStruct>()};
         }
 
-        template <typename TupleLike>
-        void store(const TupleLike& t)
+        // template <typename = std::enable_if_t<supportsValueLoad>>
+        auto operator*() const -> ValueStruct
         {
-            internal::assignTuples(asTuple(), t, std::make_index_sequence<std::tuple_size_v<TupleLike>>{});
+            static_assert(supportsValueLoad);
+            return loadAs<ValueStruct>();
         }
     };
 } // namespace llama
diff --git a/include/llama/mapping/AoS.hpp b/include/llama/mapping/AoS.hpp
index 9b3f7b1685..b859854b4f 100644
--- a/include/llama/mapping/AoS.hpp
+++ b/include/llama/mapping/AoS.hpp
@@ -18,13 +18,14 @@ namespace llama::mapping
     struct AoS
     {
         using ArrayDomain = T_ArrayDomain;
-        using DatumDomain = T_DatumDomain;
+        using DatumDomain = MakeDatumDomain<T_DatumDomain>;
+        using OriginalDatumDomain = T_DatumDomain;
         static constexpr std::size_t blobCount = 1;
 
         constexpr AoS() = default;
 
         LLAMA_FN_HOST_ACC_INLINE
-        constexpr AoS(ArrayDomain size, DatumDomain = {}) : arrayDomainSize(size)
+        constexpr AoS(ArrayDomain size, T_DatumDomain = {}) : arrayDomainSize(size)
         {
         }
 
diff --git a/include/llama/mapping/AoSoA.hpp b/include/llama/mapping/AoSoA.hpp
index b5cbd925f6..59d85d0e9f 100644
--- a/include/llama/mapping/AoSoA.hpp
+++ b/include/llama/mapping/AoSoA.hpp
@@ -21,12 +21,13 @@ namespace llama::mapping
     struct AoSoA
     {
         using ArrayDomain = T_ArrayDomain;
-        using DatumDomain = T_DatumDomain;
+        using DatumDomain = MakeDatumDomain<T_DatumDomain>;
+        using OriginalDatumDomain = T_DatumDomain;
         static constexpr std::size_t blobCount = 1;
 
         constexpr AoSoA() = default;
 
-        LLAMA_FN_HOST_ACC_INLINE constexpr AoSoA(ArrayDomain size, DatumDomain = {}) : arrayDomainSize(size)
+        LLAMA_FN_HOST_ACC_INLINE constexpr AoSoA(ArrayDomain size, T_DatumDomain = {}) : arrayDomainSize(size)
         {
         }
 
diff --git a/include/llama/mapping/Common.hpp b/include/llama/mapping/Common.hpp
index 21225522c1..e935f55839 100644
--- a/include/llama/mapping/Common.hpp
+++ b/include/llama/mapping/Common.hpp
@@ -5,6 +5,7 @@
 
 #include "../Core.hpp"
 
+#include <boost/pfr.hpp>
 #include <climits>
 
 namespace llama::mapping
@@ -125,4 +126,30 @@ namespace llama::mapping
             return r;
         }
     };
+
+    template <typename S, bool = std::is_class_v<S>>
+    struct StructToDatumStruct
+    {
+        template <std::size_t... Is>
+        static auto f(S, std::index_sequence<Is...>)
+        {
+            return DatumStruct<DatumElement<
+                DatumCoord<Is>,
+                typename StructToDatumStruct<boost::pfr::tuple_element_t<Is, S>>::type>...>{};
+        }
+
+        using type = decltype(f(S{}, std::make_index_sequence<boost::pfr::tuple_size_v<S>>{}));
+    };
+
+    template <typename S>
+    struct StructToDatumStruct<S, false>
+    {
+        using type = S;
+    };
+
+    template <typename DatumDomain>
+    using MakeDatumDomain = std::conditional_t<
+        std::is_class_v<DatumDomain> && !isDatumStruct<DatumDomain>,
+        typename StructToDatumStruct<DatumDomain>::type,
+        DatumDomain>;
 } // namespace llama::mapping
diff --git a/include/llama/mapping/One.hpp b/include/llama/mapping/One.hpp
index 790796c4d5..2fb3202b3f 100644
--- a/include/llama/mapping/One.hpp
+++ b/include/llama/mapping/One.hpp
@@ -4,6 +4,7 @@
 #pragma once
 
 #include "../Core.hpp"
+#include "Common.hpp"
 
 namespace llama::mapping
 {
@@ -14,7 +15,8 @@ namespace llama::mapping
     struct One
     {
         using ArrayDomain = T_ArrayDomain;
-        using DatumDomain = T_DatumDomain;
+        using DatumDomain = MakeDatumDomain<T_DatumDomain>;
+        using OriginalDatumDomain = T_DatumDomain;
 
         static constexpr std::size_t blobCount = 1;
 
diff --git a/include/llama/mapping/SoA.hpp b/include/llama/mapping/SoA.hpp
index f18608fa0d..e9fdea1886 100644
--- a/include/llama/mapping/SoA.hpp
+++ b/include/llama/mapping/SoA.hpp
@@ -21,7 +21,8 @@ namespace llama::mapping
     struct SoA
     {
         using ArrayDomain = T_ArrayDomain;
-        using DatumDomain = T_DatumDomain;
+        using DatumDomain = MakeDatumDomain<T_DatumDomain>;
+        using OriginalDatumDomain = T_DatumDomain;
         static constexpr std::size_t blobCount = []() constexpr
         {
             if constexpr (SeparateBuffers::value)
@@ -38,7 +39,7 @@ namespace llama::mapping
         constexpr SoA() = default;
 
         LLAMA_FN_HOST_ACC_INLINE
-        constexpr SoA(ArrayDomain size, DatumDomain = {}, SeparateBuffers = {}) : arrayDomainSize(size)
+        constexpr SoA(ArrayDomain size, T_DatumDomain = {}, SeparateBuffers = {}) : arrayDomainSize(size)
         {
         }
 
diff --git a/include/llama/mapping/SplitMapping.hpp b/include/llama/mapping/SplitMapping.hpp
index 0964b00af3..a11a586930 100644
--- a/include/llama/mapping/SplitMapping.hpp
+++ b/include/llama/mapping/SplitMapping.hpp
@@ -53,7 +53,8 @@ namespace llama::mapping
     struct SplitMapping
     {
         using ArrayDomain = T_ArrayDomain;
-        using DatumDomain = T_DatumDomain;
+        using DatumDomain = MakeDatumDomain<T_DatumDomain>;
+        using OriginalDatumDomain = T_DatumDomain;
 
         using DatumDomainPartitions = decltype(internal::partitionDatumDomain(DatumDomain{}, DatumCoordForMapping1{}));
         using DatumDomain1 = boost::mp11::mp_first<DatumDomainPartitions>;
diff --git a/include/llama/mapping/Trace.hpp b/include/llama/mapping/Trace.hpp
index 33e572db31..54418a88eb 100644
--- a/include/llama/mapping/Trace.hpp
+++ b/include/llama/mapping/Trace.hpp
@@ -36,6 +36,7 @@ namespace llama::mapping
     {
         using ArrayDomain = typename Mapping::ArrayDomain;
         using DatumDomain = typename Mapping::DatumDomain;
+        using OriginalDatumDomain = typename Mapping::OriginalDatumDomain;
         static constexpr std::size_t blobCount = Mapping::blobCount;
 
         constexpr Trace() = default;
diff --git a/include/llama/mapping/tree/Mapping.hpp b/include/llama/mapping/tree/Mapping.hpp
index c782e5ccf2..226c647cb7 100644
--- a/include/llama/mapping/tree/Mapping.hpp
+++ b/include/llama/mapping/tree/Mapping.hpp
@@ -173,6 +173,7 @@ namespace llama::mapping::tree
     {
         using ArrayDomain = T_ArrayDomain;
         using DatumDomain = T_DatumDomain;
+        using OriginalDatumDomain = T_DatumDomain;
         using BasicTree = TreeFromDomains<ArrayDomain, DatumDomain>;
         // TODO, support more than one blob
         static constexpr std::size_t blobCount = 1;
diff --git a/tests/virtualdatum.cpp b/tests/virtualdatum.cpp
index 2bfe6c0f75..f12d4076be 100644
--- a/tests/virtualdatum.cpp
+++ b/tests/virtualdatum.cpp
@@ -693,24 +693,24 @@ struct std::tuple_size<MyDatum<T>>
     static constexpr std::size_t value = 3;
 };
 
-TEST_CASE("VirtualDatum.load.value")
+TEST_CASE("VirtualDatum.convert.value")
 {
     llama::One<Name> datum;
     datum = 1;
 
     {
-        MyPos<int> pos = datum(tag::Pos{}).load();
+        MyPos<int> pos = datum(tag::Pos{});
         CHECK(pos.a == 1);
         CHECK(pos.y == 1);
     }
     {
-        MyPos<int> pos = std::as_const(datum)(tag::Pos{}).load();
+        MyPos<int> pos = std::as_const(datum)(tag::Pos{});
         CHECK(pos.a == 1);
         CHECK(pos.y == 1);
     }
 
     {
-        MyDatum<int> d = datum.load();
+        MyDatum<int> d = datum;
         CHECK(d.pos.a == 1);
         CHECK(d.pos.y == 1);
         CHECK(d.vel.x == 1);
@@ -719,7 +719,7 @@ TEST_CASE("VirtualDatum.load.value")
         CHECK(d.weight == 1);
     }
     {
-        MyDatum<int> d = std::as_const(datum).load();
+        MyDatum<int> d = std::as_const(datum);
         CHECK(d.pos.a == 1);
         CHECK(d.pos.y == 1);
         CHECK(d.vel.x == 1);
@@ -729,13 +729,13 @@ TEST_CASE("VirtualDatum.load.value")
     }
 }
 
-TEST_CASE("VirtualDatum.load.ref")
+TEST_CASE("VirtualDatum.convert.ref")
 {
     llama::One<Name> datum;
 
     datum = 1;
     {
-        MyPos<int&> pos = datum(tag::Pos{}).load();
+        MyPos<int&> pos = datum(tag::Pos{});
         CHECK(pos.a == 1);
         CHECK(pos.y == 1);
 
@@ -751,7 +751,7 @@ TEST_CASE("VirtualDatum.load.ref")
 
     datum = 1;
     {
-        MyDatum<int&> d = datum.load();
+        MyDatum<int&> d = datum;
         CHECK(d.pos.a == 1);
         CHECK(d.pos.y == 1);
 
@@ -770,41 +770,41 @@ TEST_CASE("VirtualDatum.load.ref")
     }
 }
 
-TEST_CASE("VirtualDatum.load.constref")
+TEST_CASE("VirtualDatum.convert.constref")
 {
     llama::One<Name> datum;
     datum = 1;
 
     {
-        MyPos<const int&> pos = datum(tag::Pos{}).load();
+        MyPos<const int&> pos = datum(tag::Pos{});
         CHECK(pos.a == 1);
         CHECK(pos.y == 1);
     }
     {
-        MyPos<const int&> pos = std::as_const(datum)(tag::Pos{}).load();
+        MyPos<const int&> pos = std::as_const(datum)(tag::Pos{});
         CHECK(pos.a == 1);
         CHECK(pos.y == 1);
     }
     {
-        MyDatum<const int&> d = datum.load();
+        MyDatum<const int&> d = datum;
         CHECK(d.pos.a == 1);
         CHECK(d.pos.y == 1);
     }
     {
-        MyDatum<const int&> d = std::as_const(datum).load();
+        MyDatum<const int&> d = std::as_const(datum);
         CHECK(d.pos.a == 1);
         CHECK(d.pos.y == 1);
     }
 }
 
-TEST_CASE("VirtualDatum.store")
+TEST_CASE("VirtualDatum.operator=.tuplelike")
 {
     llama::One<Name> datum;
 
     datum = 1;
     {
         MyPos<int> pos{2, 3};
-        datum(tag::Pos{}).store(pos);
+        datum(tag::Pos{}) = pos;
         CHECK(datum(tag::Pos{}, tag::A{}) == 2);
         CHECK(datum(tag::Pos{}, tag::Y{}) == 3);
         CHECK(datum(tag::Vel{}, tag::X{}) == 1);
@@ -816,7 +816,7 @@ TEST_CASE("VirtualDatum.store")
     datum = 1;
     {
         MyDatum<int> d{{2, 3}, {4, 5, 6}, 7};
-        datum.store(d);
+        datum = d;
         CHECK(datum(tag::Pos{}, tag::A{}) == 2);
         CHECK(datum(tag::Pos{}, tag::Y{}) == 3);
         CHECK(datum(tag::Vel{}, tag::X{}) == 4);
@@ -878,3 +878,121 @@ TEST_CASE("VirtualDatum.loadAs.constref")
         CHECK(pos.y == 1);
     }
 }
+
+TEST_CASE("VirtualDatum.operator=.aggregate")
+{
+    struct MyPosAgg
+    {
+        int a;
+        int y;
+    };
+
+    struct MyVelAgg
+    {
+        int x;
+        int y;
+        int z;
+    };
+
+    struct MyDatumAgg
+    {
+        MyPosAgg pos;
+        MyVelAgg vel;
+        int weight;
+    };
+
+    llama::One<Name> datum;
+
+    datum = 1;
+    {
+        MyPosAgg pos{2, 3};
+        datum(tag::Pos{}) = pos;
+        CHECK(datum(tag::Pos{}, tag::A{}) == 2);
+        CHECK(datum(tag::Pos{}, tag::Y{}) == 3);
+        CHECK(datum(tag::Vel{}, tag::X{}) == 1);
+        CHECK(datum(tag::Vel{}, tag::Y{}) == 1);
+        CHECK(datum(tag::Vel{}, tag::Z{}) == 1);
+        CHECK(datum(tag::Weight{}) == 1);
+    }
+
+    datum = 1;
+    {
+        MyDatumAgg d{{2, 3}, {4, 5, 6}, 7};
+        datum = d;
+        CHECK(datum(tag::Pos{}, tag::A{}) == 2);
+        CHECK(datum(tag::Pos{}, tag::Y{}) == 3);
+        CHECK(datum(tag::Vel{}, tag::X{}) == 4);
+        CHECK(datum(tag::Vel{}, tag::Y{}) == 5);
+        CHECK(datum(tag::Vel{}, tag::Z{}) == 6);
+        CHECK(datum(tag::Weight{}) == 7);
+    }
+}
+
+struct NameStruct
+{
+    struct Pos
+    {
+        int a;
+        int y;
+    } pos;
+
+    struct Vel
+    {
+        int x;
+        int y;
+        int z;
+    } vel;
+    int weight;
+};
+
+TEST_CASE("VirtualDatum.operator->")
+{
+    llama::One<NameStruct> datum;
+    datum = NameStruct{1, 2, 3, 4, 5, 6};
+
+    auto test = [](auto&& datum) {
+        using namespace llama::literals;
+
+        CHECK(datum->pos.a == 1);
+        CHECK(datum->pos.y == 2);
+        CHECK(datum->vel.x == 3);
+        CHECK(datum->vel.y == 4);
+        CHECK(datum->vel.z == 5);
+        CHECK(datum->weight == 6);
+
+        CHECK(datum(0_DC)->a == 1);
+        CHECK(datum(0_DC)->y == 2);
+        CHECK(datum(1_DC)->x == 3);
+        CHECK(datum(1_DC)->y == 4);
+        CHECK(datum(1_DC)->z == 5);
+    };
+    test(datum);
+    test(std::as_const(datum));
+}
+
+TEST_CASE("VirtualDatum.operator*")
+{
+    llama::One<NameStruct> datum;
+    datum = NameStruct{1, 2, 3, 4, 5, 6};
+
+    auto test = [](auto&& datum) {
+        using namespace llama::literals;
+
+        const NameStruct ns = *datum;
+        CHECK(ns.pos.a == 1);
+        CHECK(ns.pos.y == 2);
+        CHECK(ns.vel.x == 3);
+        CHECK(ns.vel.y == 4);
+        CHECK(ns.vel.z == 5);
+        CHECK(ns.weight == 6);
+        const NameStruct::Pos pos = *datum(0_DC);
+        CHECK(pos.a == 1);
+        CHECK(pos.y == 2);
+        const NameStruct::Vel vel = *datum(1_DC);
+        CHECK(vel.x == 3);
+        CHECK(vel.y == 4);
+        CHECK(vel.z == 5);
+    };
+    test(datum);
+    test(std::as_const(datum));
+}