Compiler Explorer

Source code

// This file is generated by a python script because its essientially an
// unrolled recursive structure. The CEX For Loop is instantiated Exponentially.
// This allows one to subvert the compiler's template depth limit (900 for clang
// and gcc). Instead of instantiating linearly, the implementation instantiates
// along an N-ary tree meaning the iteration count versus the maximum used
// template depth has the relationship O(n) = log(n). A more detailed
// description and the graph can be found here:
// https://www.desmos.com/calculator/izvr4h3xbs

#ifndef NARY_TREE_CEX_FOR_LOOP_IMPL_H
#define NARY_TREE_CEX_FOR_LOOP_IMPL_H

#include <cstddef>
#include <tuple>
#include <type_traits>

#include "../type_encoded_nttps_helper.h"

namespace cex_for_loop {
namespace impl {

template <typename T>
struct RemoveFirstTypeOfTuple {};
template <typename T, typename... Ts>
struct RemoveFirstTypeOfTuple<std::tuple<T, Ts...>> {
  using type = std::tuple<Ts...>;
};
template <typename IType>
// NOLINTNEXTLINE(misc-no-recursion)
constexpr IType IntegralPow(IType Base, IType Exponent) {
  return Exponent == 0 ? 1 : Base * IntegralPow(Base, Exponent - 1);
}

template <std::size_t N, typename TupleType>
using NthTypeOfTuple = typename std::tuple_element<N, TupleType>::type;

template <typename BoolExpressionFunctor, typename IType>
static constexpr int GetEnabledIteration(IType LocalStart, IType Inc, IType End,
                                         IType NthExpansion) {
  int return_value = -1;
  if (BoolExpressionFunctor::template WithType<IType>::func(
          LocalStart +
              (0 * IntegralPow(static_cast<IType>(10), NthExpansion) * Inc),
          End)) {
    return_value = 0;
  } else {
    return return_value;
  }
  if (BoolExpressionFunctor::template WithType<IType>::func(
          LocalStart +
              (1 * IntegralPow(static_cast<IType>(10), NthExpansion) * Inc),
          End)) {
    return_value = 1;
  } else {
    return return_value;
  }
  if (BoolExpressionFunctor::template WithType<IType>::func(
          LocalStart +
              (2 * IntegralPow(static_cast<IType>(10), NthExpansion) * Inc),
          End)) {
    return_value = 2;
  } else {
    return return_value;
  }
  if (BoolExpressionFunctor::template WithType<IType>::func(
          LocalStart +
              (3 * IntegralPow(static_cast<IType>(10), NthExpansion) * Inc),
          End)) {
    return_value = 3;
  } else {
    return return_value;
  }
  if (BoolExpressionFunctor::template WithType<IType>::func(
          LocalStart +
              (4 * IntegralPow(static_cast<IType>(10), NthExpansion) * Inc),
          End)) {
    return_value = 4;
  } else {
    return return_value;
  }
  if (BoolExpressionFunctor::template WithType<IType>::func(
          LocalStart +
              (5 * IntegralPow(static_cast<IType>(10), NthExpansion) * Inc),
          End)) {
    return_value = 5;
  } else {
    return return_value;
  }
  if (BoolExpressionFunctor::template WithType<IType>::func(
          LocalStart +
              (6 * IntegralPow(static_cast<IType>(10), NthExpansion) * Inc),
          End)) {
    return_value = 6;
  } else {
    return return_value;
  }
  if (BoolExpressionFunctor::template WithType<IType>::func(
          LocalStart +
              (7 * IntegralPow(static_cast<IType>(10), NthExpansion) * Inc),
          End)) {
    return_value = 7;
  } else {
    return return_value;
  }
  if (BoolExpressionFunctor::template WithType<IType>::func(
          LocalStart +
              (8 * IntegralPow(static_cast<IType>(10), NthExpansion) * Inc),
          End)) {
    return_value = 8;
  } else {
    return return_value;
  }
  if (BoolExpressionFunctor::template WithType<IType>::func(
          LocalStart +
              (9 * IntegralPow(static_cast<IType>(10), NthExpansion) * Inc),
          End)) {
    return_value = 9;
  } else {
    return return_value;
  }
  return return_value;
}

// Declare non-specialized template enabling selection of implementation
// depending on the number of NTTPs
template <typename BodyFunctor,
          std::size_t NTTPCount =
              std::tuple_size<typename BodyFunctor::OutputType>::value - 1>
struct NAryTreeCEXForLoop;

template <typename BodyFunctor>
struct NAryTreeCEXForLoop<BodyFunctor, 0> {
  template <typename IType, IType Start, IType End, IType Inc,
            typename BoolExpressionFunctor,
            typename InitialTupleWithTypeEncodedNTTPs,
            typename InitialNonCEXDataFunctor>
  class With {
   private:
    using FunctorData = typename BodyFunctor::NonConstexprData;
    using FunctorOutputType = typename BodyFunctor::OutputType;

// This implementation differs from the others in that it adapts 0 user
    // NTTPs to the 1 user NTTPs interface. Adhering to the pattern of the other
    // implementations results in a O(n) complexity for instantiation depth
    // versus required template depth rather than the desired O(log(n))
    // complexity. I (Silas Waxter) tried debugging why. I diffed the 0 user
    // NTTPs with same pattern implementation versus the 1 user NTTPs
    // implementation, and looked at each difference trying to see why it would
    // cause a different behavior. I even wrote some mocks to try to make the 0
    // user NTTPs mimic the 1 user NTTPs at the spots in which they different,
    // but this was to no avail. I ended up spending more hours than I cared, so
    // I decided to write this adapter/hider which works. The extra couple
    // templates and extra function call at **compile time** is not that
    // expensive so its okay.
    struct NTTP1Hider {
      using NonConstexprData = FunctorData;

using OutputType = std::tuple<NonConstexprData, int>;

template <IType I, int DummyNTTP>
      static constexpr OutputType func(NonConstexprData input_data) {
        FunctorData data =
            std::get<0>(BodyFunctor::template func<I>(input_data));
        return {data, DummyNTTP};
      };
    };

public:
    static constexpr FunctorOutputType func() {
      return std::get<0>(NAryTreeCEXForLoop<NTTP1Hider, 1>::template With<
                         IType, Start, End, Inc, BoolExpressionFunctor,
                         std::tuple<std::integral_constant<int, 0>>,
                         InitialNonCEXDataFunctor>::func());
    }
  };
};

template <typename BodyFunctor>
struct NAryTreeCEXForLoop<BodyFunctor, 1> {
  template <typename IType, IType Start, IType End, IType Inc,
            typename BoolExpressionFunctor,
            typename InitialTupleWithTypeEncodedNTTPs,
            typename InitialNonCEXDataFunctor>
  class With {
   private:
    using FunctorData = typename BodyFunctor::NonConstexprData;
    using FunctorOutputType = typename BodyFunctor::OutputType;

template <IType LocalStart,
              typename LocalInitialTupleWithTypeEncodedNTTPs,
              typename LocalInitialNonCEXDataFunctor>
    struct LinearExpansion0 {
      static constexpr auto kEnabledIteration =
          GetEnabledIteration<BoolExpressionFunctor, IType>(LocalStart, Inc,
                                                            End, 0);

template <IType LocalStart,
              typename LocalInitialTupleWithTypeEncodedNTTPs,
              typename LocalInitialNonCEXDataFunctor>
    struct LinearExpansion1 {
      static constexpr auto kEnabledIteration =
          GetEnabledIteration<BoolExpressionFunctor, IType>(LocalStart, Inc,
                                                            End, 1);

// Forward-declare iteration structs for partial template specialization
      // SFINAE
      template <typename UnusedType = void, typename Picker = void>
      struct I0;
      template <typename UnusedType = void, typename Picker = void>
      struct I1;
      template <typename UnusedType = void, typename Picker = void>
      struct I2;
      template <typename UnusedType = void, typename Picker = void>
      struct I3;
      template <typename UnusedType = void, typename Picker = void>
      struct I4;
      template <typename UnusedType = void, typename Picker = void>
      struct I5;
      template <typename UnusedType = void, typename Picker = void>
      struct I6;
      template <typename UnusedType = void, typename Picker = void>
      struct I7;
      template <typename UnusedType = void, typename Picker = void>
      struct I8;
      template <typename UnusedType = void, typename Picker = void>
      struct I9;
  
      template <typename UnusedType>
      struct I0<UnusedType, std::enable_if_t<(kEnabledIteration >= -1), void>> {
        // NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion0<
           LocalStart + (Inc * 0),
            LocalInitialTupleWithTypeEncodedNTTPs,
            LocalInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I1<UnusedType, std::enable_if_t<(kEnabledIteration >= 1), void>> {
        static constexpr FunctorOutputType kPriorOutput = I0<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion0<
           LocalStart + (Inc * 10),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I2<UnusedType, std::enable_if_t<(kEnabledIteration >= 2), void>> {
        static constexpr FunctorOutputType kPriorOutput = I1<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion0<
           LocalStart + (Inc * 20),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I3<UnusedType, std::enable_if_t<(kEnabledIteration >= 3), void>> {
        static constexpr FunctorOutputType kPriorOutput = I2<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion0<
           LocalStart + (Inc * 30),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I4<UnusedType, std::enable_if_t<(kEnabledIteration >= 4), void>> {
        static constexpr FunctorOutputType kPriorOutput = I3<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion0<
           LocalStart + (Inc * 40),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I5<UnusedType, std::enable_if_t<(kEnabledIteration >= 5), void>> {
        static constexpr FunctorOutputType kPriorOutput = I4<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion0<
           LocalStart + (Inc * 50),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I6<UnusedType, std::enable_if_t<(kEnabledIteration >= 6), void>> {
        static constexpr FunctorOutputType kPriorOutput = I5<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion0<
           LocalStart + (Inc * 60),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I7<UnusedType, std::enable_if_t<(kEnabledIteration >= 7), void>> {
        static constexpr FunctorOutputType kPriorOutput = I6<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion0<
           LocalStart + (Inc * 70),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I8<UnusedType, std::enable_if_t<(kEnabledIteration >= 8), void>> {
        static constexpr FunctorOutputType kPriorOutput = I7<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion0<
           LocalStart + (Inc * 80),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I9<UnusedType, std::enable_if_t<(kEnabledIteration >= 9), void>> {
        static constexpr FunctorOutputType kPriorOutput = I8<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion0<
           LocalStart + (Inc * 90),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      // Create SFINAE function that returns the value from the last iteration
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI <= 0, FunctorOutputType> {
        return I0<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 1, FunctorOutputType> {
        return I1<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 2, FunctorOutputType> {
        return I2<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 3, FunctorOutputType> {
        return I3<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 4, FunctorOutputType> {
        return I4<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 5, FunctorOutputType> {
        return I5<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 6, FunctorOutputType> {
        return I6<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 7, FunctorOutputType> {
        return I7<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 8, FunctorOutputType> {
        return I8<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 9, FunctorOutputType> {
        return I9<>::kValue;
      }
    };
    template <IType LocalStart,
              typename LocalInitialTupleWithTypeEncodedNTTPs,
              typename LocalInitialNonCEXDataFunctor>
    struct LinearExpansion2 {
      static constexpr auto kEnabledIteration =
          GetEnabledIteration<BoolExpressionFunctor, IType>(LocalStart, Inc,
                                                            End, 2);

// Forward-declare iteration structs for partial template specialization
      // SFINAE
      template <typename UnusedType = void, typename Picker = void>
      struct I0;
      template <typename UnusedType = void, typename Picker = void>
      struct I1;
      template <typename UnusedType = void, typename Picker = void>
      struct I2;
      template <typename UnusedType = void, typename Picker = void>
      struct I3;
      template <typename UnusedType = void, typename Picker = void>
      struct I4;
      template <typename UnusedType = void, typename Picker = void>
      struct I5;
      template <typename UnusedType = void, typename Picker = void>
      struct I6;
      template <typename UnusedType = void, typename Picker = void>
      struct I7;
      template <typename UnusedType = void, typename Picker = void>
      struct I8;
      template <typename UnusedType = void, typename Picker = void>
      struct I9;
  
      template <typename UnusedType>
      struct I0<UnusedType, std::enable_if_t<(kEnabledIteration >= -1), void>> {
        // NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion1<
           LocalStart + (Inc * 0),
            LocalInitialTupleWithTypeEncodedNTTPs,
            LocalInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I1<UnusedType, std::enable_if_t<(kEnabledIteration >= 1), void>> {
        static constexpr FunctorOutputType kPriorOutput = I0<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion1<
           LocalStart + (Inc * 100),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I2<UnusedType, std::enable_if_t<(kEnabledIteration >= 2), void>> {
        static constexpr FunctorOutputType kPriorOutput = I1<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion1<
           LocalStart + (Inc * 200),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I3<UnusedType, std::enable_if_t<(kEnabledIteration >= 3), void>> {
        static constexpr FunctorOutputType kPriorOutput = I2<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion1<
           LocalStart + (Inc * 300),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I4<UnusedType, std::enable_if_t<(kEnabledIteration >= 4), void>> {
        static constexpr FunctorOutputType kPriorOutput = I3<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion1<
           LocalStart + (Inc * 400),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I5<UnusedType, std::enable_if_t<(kEnabledIteration >= 5), void>> {
        static constexpr FunctorOutputType kPriorOutput = I4<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion1<
           LocalStart + (Inc * 500),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I6<UnusedType, std::enable_if_t<(kEnabledIteration >= 6), void>> {
        static constexpr FunctorOutputType kPriorOutput = I5<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion1<
           LocalStart + (Inc * 600),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I7<UnusedType, std::enable_if_t<(kEnabledIteration >= 7), void>> {
        static constexpr FunctorOutputType kPriorOutput = I6<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion1<
           LocalStart + (Inc * 700),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I8<UnusedType, std::enable_if_t<(kEnabledIteration >= 8), void>> {
        static constexpr FunctorOutputType kPriorOutput = I7<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion1<
           LocalStart + (Inc * 800),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I9<UnusedType, std::enable_if_t<(kEnabledIteration >= 9), void>> {
        static constexpr FunctorOutputType kPriorOutput = I8<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion1<
           LocalStart + (Inc * 900),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      // Create SFINAE function that returns the value from the last iteration
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI <= 0, FunctorOutputType> {
        return I0<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 1, FunctorOutputType> {
        return I1<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 2, FunctorOutputType> {
        return I2<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 3, FunctorOutputType> {
        return I3<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 4, FunctorOutputType> {
        return I4<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 5, FunctorOutputType> {
        return I5<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 6, FunctorOutputType> {
        return I6<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 7, FunctorOutputType> {
        return I7<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 8, FunctorOutputType> {
        return I8<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 9, FunctorOutputType> {
        return I9<>::kValue;
      }
    };
    template <IType LocalStart,
              typename LocalInitialTupleWithTypeEncodedNTTPs,
              typename LocalInitialNonCEXDataFunctor>
    struct LinearExpansion3 {
      static constexpr auto kEnabledIteration =
          GetEnabledIteration<BoolExpressionFunctor, IType>(LocalStart, Inc,
                                                            End, 3);

// Forward-declare iteration structs for partial template specialization
      // SFINAE
      template <typename UnusedType = void, typename Picker = void>
      struct I0;
      template <typename UnusedType = void, typename Picker = void>
      struct I1;
      template <typename UnusedType = void, typename Picker = void>
      struct I2;
      template <typename UnusedType = void, typename Picker = void>
      struct I3;
      template <typename UnusedType = void, typename Picker = void>
      struct I4;
      template <typename UnusedType = void, typename Picker = void>
      struct I5;
      template <typename UnusedType = void, typename Picker = void>
      struct I6;
      template <typename UnusedType = void, typename Picker = void>
      struct I7;
      template <typename UnusedType = void, typename Picker = void>
      struct I8;
      template <typename UnusedType = void, typename Picker = void>
      struct I9;
  
      template <typename UnusedType>
      struct I0<UnusedType, std::enable_if_t<(kEnabledIteration >= -1), void>> {
        // NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion2<
           LocalStart + (Inc * 0),
            LocalInitialTupleWithTypeEncodedNTTPs,
            LocalInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I1<UnusedType, std::enable_if_t<(kEnabledIteration >= 1), void>> {
        static constexpr FunctorOutputType kPriorOutput = I0<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion2<
           LocalStart + (Inc * 1000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I2<UnusedType, std::enable_if_t<(kEnabledIteration >= 2), void>> {
        static constexpr FunctorOutputType kPriorOutput = I1<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion2<
           LocalStart + (Inc * 2000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I3<UnusedType, std::enable_if_t<(kEnabledIteration >= 3), void>> {
        static constexpr FunctorOutputType kPriorOutput = I2<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion2<
           LocalStart + (Inc * 3000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I4<UnusedType, std::enable_if_t<(kEnabledIteration >= 4), void>> {
        static constexpr FunctorOutputType kPriorOutput = I3<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion2<
           LocalStart + (Inc * 4000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I5<UnusedType, std::enable_if_t<(kEnabledIteration >= 5), void>> {
        static constexpr FunctorOutputType kPriorOutput = I4<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion2<
           LocalStart + (Inc * 5000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I6<UnusedType, std::enable_if_t<(kEnabledIteration >= 6), void>> {
        static constexpr FunctorOutputType kPriorOutput = I5<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion2<
           LocalStart + (Inc * 6000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I7<UnusedType, std::enable_if_t<(kEnabledIteration >= 7), void>> {
        static constexpr FunctorOutputType kPriorOutput = I6<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion2<
           LocalStart + (Inc * 7000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I8<UnusedType, std::enable_if_t<(kEnabledIteration >= 8), void>> {
        static constexpr FunctorOutputType kPriorOutput = I7<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion2<
           LocalStart + (Inc * 8000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I9<UnusedType, std::enable_if_t<(kEnabledIteration >= 9), void>> {
        static constexpr FunctorOutputType kPriorOutput = I8<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion2<
           LocalStart + (Inc * 9000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      // Create SFINAE function that returns the value from the last iteration
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI <= 0, FunctorOutputType> {
        return I0<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 1, FunctorOutputType> {
        return I1<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 2, FunctorOutputType> {
        return I2<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 3, FunctorOutputType> {
        return I3<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 4, FunctorOutputType> {
        return I4<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 5, FunctorOutputType> {
        return I5<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 6, FunctorOutputType> {
        return I6<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 7, FunctorOutputType> {
        return I7<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 8, FunctorOutputType> {
        return I8<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 9, FunctorOutputType> {
        return I9<>::kValue;
      }
    };
    template <IType LocalStart,
              typename LocalInitialTupleWithTypeEncodedNTTPs,
              typename LocalInitialNonCEXDataFunctor>
    struct LinearExpansion4 {
      static constexpr auto kEnabledIteration =
          GetEnabledIteration<BoolExpressionFunctor, IType>(LocalStart, Inc,
                                                            End, 4);

// Forward-declare iteration structs for partial template specialization
      // SFINAE
      template <typename UnusedType = void, typename Picker = void>
      struct I0;
      template <typename UnusedType = void, typename Picker = void>
      struct I1;
      template <typename UnusedType = void, typename Picker = void>
      struct I2;
      template <typename UnusedType = void, typename Picker = void>
      struct I3;
      template <typename UnusedType = void, typename Picker = void>
      struct I4;
      template <typename UnusedType = void, typename Picker = void>
      struct I5;
      template <typename UnusedType = void, typename Picker = void>
      struct I6;
      template <typename UnusedType = void, typename Picker = void>
      struct I7;
      template <typename UnusedType = void, typename Picker = void>
      struct I8;
      template <typename UnusedType = void, typename Picker = void>
      struct I9;
  
      template <typename UnusedType>
      struct I0<UnusedType, std::enable_if_t<(kEnabledIteration >= -1), void>> {
        // NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion3<
           LocalStart + (Inc * 0),
            LocalInitialTupleWithTypeEncodedNTTPs,
            LocalInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I1<UnusedType, std::enable_if_t<(kEnabledIteration >= 1), void>> {
        static constexpr FunctorOutputType kPriorOutput = I0<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion3<
           LocalStart + (Inc * 10000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I2<UnusedType, std::enable_if_t<(kEnabledIteration >= 2), void>> {
        static constexpr FunctorOutputType kPriorOutput = I1<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion3<
           LocalStart + (Inc * 20000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I3<UnusedType, std::enable_if_t<(kEnabledIteration >= 3), void>> {
        static constexpr FunctorOutputType kPriorOutput = I2<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion3<
           LocalStart + (Inc * 30000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I4<UnusedType, std::enable_if_t<(kEnabledIteration >= 4), void>> {
        static constexpr FunctorOutputType kPriorOutput = I3<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion3<
           LocalStart + (Inc * 40000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I5<UnusedType, std::enable_if_t<(kEnabledIteration >= 5), void>> {
        static constexpr FunctorOutputType kPriorOutput = I4<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion3<
           LocalStart + (Inc * 50000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I6<UnusedType, std::enable_if_t<(kEnabledIteration >= 6), void>> {
        static constexpr FunctorOutputType kPriorOutput = I5<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion3<
           LocalStart + (Inc * 60000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I7<UnusedType, std::enable_if_t<(kEnabledIteration >= 7), void>> {
        static constexpr FunctorOutputType kPriorOutput = I6<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion3<
           LocalStart + (Inc * 70000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I8<UnusedType, std::enable_if_t<(kEnabledIteration >= 8), void>> {
        static constexpr FunctorOutputType kPriorOutput = I7<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion3<
           LocalStart + (Inc * 80000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I9<UnusedType, std::enable_if_t<(kEnabledIteration >= 9), void>> {
        static constexpr FunctorOutputType kPriorOutput = I8<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion3<
           LocalStart + (Inc * 90000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      // Create SFINAE function that returns the value from the last iteration
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI <= 0, FunctorOutputType> {
        return I0<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 1, FunctorOutputType> {
        return I1<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 2, FunctorOutputType> {
        return I2<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 3, FunctorOutputType> {
        return I3<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 4, FunctorOutputType> {
        return I4<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 5, FunctorOutputType> {
        return I5<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 6, FunctorOutputType> {
        return I6<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 7, FunctorOutputType> {
        return I7<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 8, FunctorOutputType> {
        return I8<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 9, FunctorOutputType> {
        return I9<>::kValue;
      }
    };
    template <IType LocalStart,
              typename LocalInitialTupleWithTypeEncodedNTTPs,
              typename LocalInitialNonCEXDataFunctor>
    struct LinearExpansion5 {
      static constexpr auto kEnabledIteration =
          GetEnabledIteration<BoolExpressionFunctor, IType>(LocalStart, Inc,
                                                            End, 5);

// Forward-declare iteration structs for partial template specialization
      // SFINAE
      template <typename UnusedType = void, typename Picker = void>
      struct I0;
      template <typename UnusedType = void, typename Picker = void>
      struct I1;
      template <typename UnusedType = void, typename Picker = void>
      struct I2;
      template <typename UnusedType = void, typename Picker = void>
      struct I3;
      template <typename UnusedType = void, typename Picker = void>
      struct I4;
      template <typename UnusedType = void, typename Picker = void>
      struct I5;
      template <typename UnusedType = void, typename Picker = void>
      struct I6;
      template <typename UnusedType = void, typename Picker = void>
      struct I7;
      template <typename UnusedType = void, typename Picker = void>
      struct I8;
      template <typename UnusedType = void, typename Picker = void>
      struct I9;
  
      template <typename UnusedType>
      struct I0<UnusedType, std::enable_if_t<(kEnabledIteration >= -1), void>> {
        // NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion4<
           LocalStart + (Inc * 0),
            LocalInitialTupleWithTypeEncodedNTTPs,
            LocalInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I1<UnusedType, std::enable_if_t<(kEnabledIteration >= 1), void>> {
        static constexpr FunctorOutputType kPriorOutput = I0<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion4<
           LocalStart + (Inc * 100000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I2<UnusedType, std::enable_if_t<(kEnabledIteration >= 2), void>> {
        static constexpr FunctorOutputType kPriorOutput = I1<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion4<
           LocalStart + (Inc * 200000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I3<UnusedType, std::enable_if_t<(kEnabledIteration >= 3), void>> {
        static constexpr FunctorOutputType kPriorOutput = I2<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion4<
           LocalStart + (Inc * 300000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I4<UnusedType, std::enable_if_t<(kEnabledIteration >= 4), void>> {
        static constexpr FunctorOutputType kPriorOutput = I3<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion4<
           LocalStart + (Inc * 400000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I5<UnusedType, std::enable_if_t<(kEnabledIteration >= 5), void>> {
        static constexpr FunctorOutputType kPriorOutput = I4<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion4<
           LocalStart + (Inc * 500000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I6<UnusedType, std::enable_if_t<(kEnabledIteration >= 6), void>> {
        static constexpr FunctorOutputType kPriorOutput = I5<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion4<
           LocalStart + (Inc * 600000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I7<UnusedType, std::enable_if_t<(kEnabledIteration >= 7), void>> {
        static constexpr FunctorOutputType kPriorOutput = I6<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion4<
           LocalStart + (Inc * 700000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I8<UnusedType, std::enable_if_t<(kEnabledIteration >= 8), void>> {
        static constexpr FunctorOutputType kPriorOutput = I7<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion4<
           LocalStart + (Inc * 800000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I9<UnusedType, std::enable_if_t<(kEnabledIteration >= 9), void>> {
        static constexpr FunctorOutputType kPriorOutput = I8<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion4<
           LocalStart + (Inc * 900000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      // Create SFINAE function that returns the value from the last iteration
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI <= 0, FunctorOutputType> {
        return I0<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 1, FunctorOutputType> {
        return I1<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 2, FunctorOutputType> {
        return I2<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 3, FunctorOutputType> {
        return I3<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 4, FunctorOutputType> {
        return I4<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 5, FunctorOutputType> {
        return I5<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 6, FunctorOutputType> {
        return I6<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 7, FunctorOutputType> {
        return I7<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 8, FunctorOutputType> {
        return I8<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 9, FunctorOutputType> {
        return I9<>::kValue;
      }
    };
    template <IType LocalStart,
              typename LocalInitialTupleWithTypeEncodedNTTPs,
              typename LocalInitialNonCEXDataFunctor>
    struct LinearExpansion6 {
      static constexpr auto kEnabledIteration =
          GetEnabledIteration<BoolExpressionFunctor, IType>(LocalStart, Inc,
                                                            End, 6);

// Forward-declare iteration structs for partial template specialization
      // SFINAE
      template <typename UnusedType = void, typename Picker = void>
      struct I0;
      template <typename UnusedType = void, typename Picker = void>
      struct I1;
      template <typename UnusedType = void, typename Picker = void>
      struct I2;
      template <typename UnusedType = void, typename Picker = void>
      struct I3;
      template <typename UnusedType = void, typename Picker = void>
      struct I4;
      template <typename UnusedType = void, typename Picker = void>
      struct I5;
      template <typename UnusedType = void, typename Picker = void>
      struct I6;
      template <typename UnusedType = void, typename Picker = void>
      struct I7;
      template <typename UnusedType = void, typename Picker = void>
      struct I8;
      template <typename UnusedType = void, typename Picker = void>
      struct I9;
  
      template <typename UnusedType>
      struct I0<UnusedType, std::enable_if_t<(kEnabledIteration >= -1), void>> {
        // NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion5<
           LocalStart + (Inc * 0),
            LocalInitialTupleWithTypeEncodedNTTPs,
            LocalInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I1<UnusedType, std::enable_if_t<(kEnabledIteration >= 1), void>> {
        static constexpr FunctorOutputType kPriorOutput = I0<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion5<
           LocalStart + (Inc * 1000000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I2<UnusedType, std::enable_if_t<(kEnabledIteration >= 2), void>> {
        static constexpr FunctorOutputType kPriorOutput = I1<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion5<
           LocalStart + (Inc * 2000000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I3<UnusedType, std::enable_if_t<(kEnabledIteration >= 3), void>> {
        static constexpr FunctorOutputType kPriorOutput = I2<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion5<
           LocalStart + (Inc * 3000000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I4<UnusedType, std::enable_if_t<(kEnabledIteration >= 4), void>> {
        static constexpr FunctorOutputType kPriorOutput = I3<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion5<
           LocalStart + (Inc * 4000000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I5<UnusedType, std::enable_if_t<(kEnabledIteration >= 5), void>> {
        static constexpr FunctorOutputType kPriorOutput = I4<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion5<
           LocalStart + (Inc * 5000000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I6<UnusedType, std::enable_if_t<(kEnabledIteration >= 6), void>> {
        static constexpr FunctorOutputType kPriorOutput = I5<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion5<
           LocalStart + (Inc * 6000000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I7<UnusedType, std::enable_if_t<(kEnabledIteration >= 7), void>> {
        static constexpr FunctorOutputType kPriorOutput = I6<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion5<
           LocalStart + (Inc * 7000000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I8<UnusedType, std::enable_if_t<(kEnabledIteration >= 8), void>> {
        static constexpr FunctorOutputType kPriorOutput = I7<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion5<
           LocalStart + (Inc * 8000000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I9<UnusedType, std::enable_if_t<(kEnabledIteration >= 9), void>> {
        static constexpr FunctorOutputType kPriorOutput = I8<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion5<
           LocalStart + (Inc * 9000000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      // Create SFINAE function that returns the value from the last iteration
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI <= 0, FunctorOutputType> {
        return I0<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 1, FunctorOutputType> {
        return I1<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 2, FunctorOutputType> {
        return I2<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 3, FunctorOutputType> {
        return I3<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 4, FunctorOutputType> {
        return I4<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 5, FunctorOutputType> {
        return I5<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 6, FunctorOutputType> {
        return I6<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 7, FunctorOutputType> {
        return I7<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 8, FunctorOutputType> {
        return I8<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 9, FunctorOutputType> {
        return I9<>::kValue;
      }
    };
   public:
    static constexpr FunctorOutputType func() {
      return LinearExpansion6<Start, InitialTupleWithTypeEncodedNTTPs,
                              InitialNonCEXDataFunctor>::func();
    }
  };
};

template <typename BodyFunctor>
struct NAryTreeCEXForLoop<BodyFunctor, 2> {
  template <typename IType, IType Start, IType End, IType Inc,
            typename BoolExpressionFunctor,
            typename InitialTupleWithTypeEncodedNTTPs,
            typename InitialNonCEXDataFunctor>
  class With {
   private:
    using FunctorData = typename BodyFunctor::NonConstexprData;
    using FunctorOutputType = typename BodyFunctor::OutputType;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion0<
           LocalStart + (Inc * 10),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I2<UnusedType, std::enable_if_t<(kEnabledIteration >= 2), void>> {
        static constexpr FunctorOutputType kPriorOutput = I1<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion0<
           LocalStart + (Inc * 20),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I3<UnusedType, std::enable_if_t<(kEnabledIteration >= 3), void>> {
        static constexpr FunctorOutputType kPriorOutput = I2<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion0<
           LocalStart + (Inc * 30),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I4<UnusedType, std::enable_if_t<(kEnabledIteration >= 4), void>> {
        static constexpr FunctorOutputType kPriorOutput = I3<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion0<
           LocalStart + (Inc * 40),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I5<UnusedType, std::enable_if_t<(kEnabledIteration >= 5), void>> {
        static constexpr FunctorOutputType kPriorOutput = I4<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion0<
           LocalStart + (Inc * 50),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I6<UnusedType, std::enable_if_t<(kEnabledIteration >= 6), void>> {
        static constexpr FunctorOutputType kPriorOutput = I5<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion0<
           LocalStart + (Inc * 60),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I7<UnusedType, std::enable_if_t<(kEnabledIteration >= 7), void>> {
        static constexpr FunctorOutputType kPriorOutput = I6<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion0<
           LocalStart + (Inc * 70),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I8<UnusedType, std::enable_if_t<(kEnabledIteration >= 8), void>> {
        static constexpr FunctorOutputType kPriorOutput = I7<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion0<
           LocalStart + (Inc * 80),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I9<UnusedType, std::enable_if_t<(kEnabledIteration >= 9), void>> {
        static constexpr FunctorOutputType kPriorOutput = I8<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion0<
           LocalStart + (Inc * 90),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      // Create SFINAE function that returns the value from the last iteration
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI <= 0, FunctorOutputType> {
        return I0<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 1, FunctorOutputType> {
        return I1<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 2, FunctorOutputType> {
        return I2<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 3, FunctorOutputType> {
        return I3<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 4, FunctorOutputType> {
        return I4<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 5, FunctorOutputType> {
        return I5<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 6, FunctorOutputType> {
        return I6<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 7, FunctorOutputType> {
        return I7<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 8, FunctorOutputType> {
        return I8<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 9, FunctorOutputType> {
        return I9<>::kValue;
      }
    };
    template <IType LocalStart,
              typename LocalInitialTupleWithTypeEncodedNTTPs,
              typename LocalInitialNonCEXDataFunctor>
    struct LinearExpansion2 {
      static constexpr auto kEnabledIteration =
          GetEnabledIteration<BoolExpressionFunctor, IType>(LocalStart, Inc,
                                                            End, 2);

// Forward-declare iteration structs for partial template specialization
      // SFINAE
      template <typename UnusedType = void, typename Picker = void>
      struct I0;
      template <typename UnusedType = void, typename Picker = void>
      struct I1;
      template <typename UnusedType = void, typename Picker = void>
      struct I2;
      template <typename UnusedType = void, typename Picker = void>
      struct I3;
      template <typename UnusedType = void, typename Picker = void>
      struct I4;
      template <typename UnusedType = void, typename Picker = void>
      struct I5;
      template <typename UnusedType = void, typename Picker = void>
      struct I6;
      template <typename UnusedType = void, typename Picker = void>
      struct I7;
      template <typename UnusedType = void, typename Picker = void>
      struct I8;
      template <typename UnusedType = void, typename Picker = void>
      struct I9;
  
      template <typename UnusedType>
      struct I0<UnusedType, std::enable_if_t<(kEnabledIteration >= -1), void>> {
        // NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion1<
           LocalStart + (Inc * 0),
            LocalInitialTupleWithTypeEncodedNTTPs,
            LocalInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I1<UnusedType, std::enable_if_t<(kEnabledIteration >= 1), void>> {
        static constexpr FunctorOutputType kPriorOutput = I0<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion1<
           LocalStart + (Inc * 100),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I2<UnusedType, std::enable_if_t<(kEnabledIteration >= 2), void>> {
        static constexpr FunctorOutputType kPriorOutput = I1<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion1<
           LocalStart + (Inc * 200),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I3<UnusedType, std::enable_if_t<(kEnabledIteration >= 3), void>> {
        static constexpr FunctorOutputType kPriorOutput = I2<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion1<
           LocalStart + (Inc * 300),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I4<UnusedType, std::enable_if_t<(kEnabledIteration >= 4), void>> {
        static constexpr FunctorOutputType kPriorOutput = I3<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion1<
           LocalStart + (Inc * 400),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I5<UnusedType, std::enable_if_t<(kEnabledIteration >= 5), void>> {
        static constexpr FunctorOutputType kPriorOutput = I4<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion1<
           LocalStart + (Inc * 500),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I6<UnusedType, std::enable_if_t<(kEnabledIteration >= 6), void>> {
        static constexpr FunctorOutputType kPriorOutput = I5<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion1<
           LocalStart + (Inc * 600),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I7<UnusedType, std::enable_if_t<(kEnabledIteration >= 7), void>> {
        static constexpr FunctorOutputType kPriorOutput = I6<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion1<
           LocalStart + (Inc * 700),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I8<UnusedType, std::enable_if_t<(kEnabledIteration >= 8), void>> {
        static constexpr FunctorOutputType kPriorOutput = I7<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion1<
           LocalStart + (Inc * 800),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I9<UnusedType, std::enable_if_t<(kEnabledIteration >= 9), void>> {
        static constexpr FunctorOutputType kPriorOutput = I8<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion1<
           LocalStart + (Inc * 900),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      // Create SFINAE function that returns the value from the last iteration
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI <= 0, FunctorOutputType> {
        return I0<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 1, FunctorOutputType> {
        return I1<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 2, FunctorOutputType> {
        return I2<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 3, FunctorOutputType> {
        return I3<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 4, FunctorOutputType> {
        return I4<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 5, FunctorOutputType> {
        return I5<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 6, FunctorOutputType> {
        return I6<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 7, FunctorOutputType> {
        return I7<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 8, FunctorOutputType> {
        return I8<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 9, FunctorOutputType> {
        return I9<>::kValue;
      }
    };
    template <IType LocalStart,
              typename LocalInitialTupleWithTypeEncodedNTTPs,
              typename LocalInitialNonCEXDataFunctor>
    struct LinearExpansion3 {
      static constexpr auto kEnabledIteration =
          GetEnabledIteration<BoolExpressionFunctor, IType>(LocalStart, Inc,
                                                            End, 3);

// Forward-declare iteration structs for partial template specialization
      // SFINAE
      template <typename UnusedType = void, typename Picker = void>
      struct I0;
      template <typename UnusedType = void, typename Picker = void>
      struct I1;
      template <typename UnusedType = void, typename Picker = void>
      struct I2;
      template <typename UnusedType = void, typename Picker = void>
      struct I3;
      template <typename UnusedType = void, typename Picker = void>
      struct I4;
      template <typename UnusedType = void, typename Picker = void>
      struct I5;
      template <typename UnusedType = void, typename Picker = void>
      struct I6;
      template <typename UnusedType = void, typename Picker = void>
      struct I7;
      template <typename UnusedType = void, typename Picker = void>
      struct I8;
      template <typename UnusedType = void, typename Picker = void>
      struct I9;
  
      template <typename UnusedType>
      struct I0<UnusedType, std::enable_if_t<(kEnabledIteration >= -1), void>> {
        // NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion2<
           LocalStart + (Inc * 0),
            LocalInitialTupleWithTypeEncodedNTTPs,
            LocalInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I1<UnusedType, std::enable_if_t<(kEnabledIteration >= 1), void>> {
        static constexpr FunctorOutputType kPriorOutput = I0<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion2<
           LocalStart + (Inc * 1000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I2<UnusedType, std::enable_if_t<(kEnabledIteration >= 2), void>> {
        static constexpr FunctorOutputType kPriorOutput = I1<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion2<
           LocalStart + (Inc * 2000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I3<UnusedType, std::enable_if_t<(kEnabledIteration >= 3), void>> {
        static constexpr FunctorOutputType kPriorOutput = I2<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion2<
           LocalStart + (Inc * 3000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I4<UnusedType, std::enable_if_t<(kEnabledIteration >= 4), void>> {
        static constexpr FunctorOutputType kPriorOutput = I3<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion2<
           LocalStart + (Inc * 4000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I5<UnusedType, std::enable_if_t<(kEnabledIteration >= 5), void>> {
        static constexpr FunctorOutputType kPriorOutput = I4<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion2<
           LocalStart + (Inc * 5000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I6<UnusedType, std::enable_if_t<(kEnabledIteration >= 6), void>> {
        static constexpr FunctorOutputType kPriorOutput = I5<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion2<
           LocalStart + (Inc * 6000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I7<UnusedType, std::enable_if_t<(kEnabledIteration >= 7), void>> {
        static constexpr FunctorOutputType kPriorOutput = I6<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion2<
           LocalStart + (Inc * 7000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I8<UnusedType, std::enable_if_t<(kEnabledIteration >= 8), void>> {
        static constexpr FunctorOutputType kPriorOutput = I7<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion2<
           LocalStart + (Inc * 8000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I9<UnusedType, std::enable_if_t<(kEnabledIteration >= 9), void>> {
        static constexpr FunctorOutputType kPriorOutput = I8<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion2<
           LocalStart + (Inc * 9000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      // Create SFINAE function that returns the value from the last iteration
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI <= 0, FunctorOutputType> {
        return I0<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 1, FunctorOutputType> {
        return I1<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 2, FunctorOutputType> {
        return I2<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 3, FunctorOutputType> {
        return I3<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 4, FunctorOutputType> {
        return I4<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 5, FunctorOutputType> {
        return I5<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 6, FunctorOutputType> {
        return I6<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 7, FunctorOutputType> {
        return I7<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 8, FunctorOutputType> {
        return I8<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 9, FunctorOutputType> {
        return I9<>::kValue;
      }
    };
    template <IType LocalStart,
              typename LocalInitialTupleWithTypeEncodedNTTPs,
              typename LocalInitialNonCEXDataFunctor>
    struct LinearExpansion4 {
      static constexpr auto kEnabledIteration =
          GetEnabledIteration<BoolExpressionFunctor, IType>(LocalStart, Inc,
                                                            End, 4);

// Forward-declare iteration structs for partial template specialization
      // SFINAE
      template <typename UnusedType = void, typename Picker = void>
      struct I0;
      template <typename UnusedType = void, typename Picker = void>
      struct I1;
      template <typename UnusedType = void, typename Picker = void>
      struct I2;
      template <typename UnusedType = void, typename Picker = void>
      struct I3;
      template <typename UnusedType = void, typename Picker = void>
      struct I4;
      template <typename UnusedType = void, typename Picker = void>
      struct I5;
      template <typename UnusedType = void, typename Picker = void>
      struct I6;
      template <typename UnusedType = void, typename Picker = void>
      struct I7;
      template <typename UnusedType = void, typename Picker = void>
      struct I8;
      template <typename UnusedType = void, typename Picker = void>
      struct I9;
  
      template <typename UnusedType>
      struct I0<UnusedType, std::enable_if_t<(kEnabledIteration >= -1), void>> {
        // NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion3<
           LocalStart + (Inc * 0),
            LocalInitialTupleWithTypeEncodedNTTPs,
            LocalInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I1<UnusedType, std::enable_if_t<(kEnabledIteration >= 1), void>> {
        static constexpr FunctorOutputType kPriorOutput = I0<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion3<
           LocalStart + (Inc * 10000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I2<UnusedType, std::enable_if_t<(kEnabledIteration >= 2), void>> {
        static constexpr FunctorOutputType kPriorOutput = I1<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion3<
           LocalStart + (Inc * 20000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I3<UnusedType, std::enable_if_t<(kEnabledIteration >= 3), void>> {
        static constexpr FunctorOutputType kPriorOutput = I2<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion3<
           LocalStart + (Inc * 30000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I4<UnusedType, std::enable_if_t<(kEnabledIteration >= 4), void>> {
        static constexpr FunctorOutputType kPriorOutput = I3<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion3<
           LocalStart + (Inc * 40000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I5<UnusedType, std::enable_if_t<(kEnabledIteration >= 5), void>> {
        static constexpr FunctorOutputType kPriorOutput = I4<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion3<
           LocalStart + (Inc * 50000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I6<UnusedType, std::enable_if_t<(kEnabledIteration >= 6), void>> {
        static constexpr FunctorOutputType kPriorOutput = I5<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion3<
           LocalStart + (Inc * 60000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I7<UnusedType, std::enable_if_t<(kEnabledIteration >= 7), void>> {
        static constexpr FunctorOutputType kPriorOutput = I6<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion3<
           LocalStart + (Inc * 70000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I8<UnusedType, std::enable_if_t<(kEnabledIteration >= 8), void>> {
        static constexpr FunctorOutputType kPriorOutput = I7<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion3<
           LocalStart + (Inc * 80000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I9<UnusedType, std::enable_if_t<(kEnabledIteration >= 9), void>> {
        static constexpr FunctorOutputType kPriorOutput = I8<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion3<
           LocalStart + (Inc * 90000),
            typename TypeEncodedNTTPs<BodyFunctor>::template type<
                std::get<1>(kPriorOutput),
                std::get<2>(kPriorOutput)>,
            NextInitialNonCEXDataFunctor>::func();
      };
      // Create SFINAE function that returns the value from the last iteration
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI <= 0, FunctorOutputType> {
        return I0<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 1, FunctorOutputType> {
        return I1<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 2, FunctorOutputType> {
        return I2<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 3, FunctorOutputType> {
        return I3<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 4, FunctorOutputType> {
        return I4<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 5, FunctorOutputType> {
        return I5<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 6, FunctorOutputType> {
        return I6<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 7, FunctorOutputType> {
        return I7<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 8, FunctorOutputType> {
        return I8<>::kValue;
      }
      template <int LastEnabledI = kEnabledIteration>
      static constexpr auto func()
          -> std::enable_if_t<LastEnabledI == 9, FunctorOutputType> {
        return I9<>::kValue;
      }
    };
    template <IType LocalStart,
              typename LocalInitialTupleWithTypeEncodedNTTPs,
              typename LocalInitialNonCEXDataFunctor>
    struct LinearExpansion5 {
      static constexpr auto kEnabledIteration =
          GetEnabledIteration<BoolExpressionFunctor, IType>(LocalStart, Inc,
                                                            End, 5);

// Forward-declare iteration structs for partial template specialization
      // SFINAE
      template <typename UnusedType = void, typename Picker = void>
      struct I0;
      template <typename UnusedType = void, typename Picker = void>
      struct I1;
      template <typename UnusedType = void, typename Picker = void>
      struct I2;
      template <typename UnusedType = void, typename Picker = void>
      struct I3;
      template <typename UnusedType = void, typename Picker = void>
      struct I4;
      template <typename UnusedType = void, typename Picker = void>
      struct I5;
      template <typename UnusedType = void, typename Picker = void>
      struct I6;
      template <typename UnusedType = void, typename Picker = void>
      struct I7;
      template <typename UnusedType = void, typename Picker = void>
      struct I8;
      template <typename UnusedType = void, typename Picker = void>
      struct I9;
  
      template <typename UnusedType>
      struct I0<UnusedType, std::enable_if_t<(kEnabledIteration >= -1), void>> {
        // NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion4<
           LocalStart + (Inc * 0),
            LocalInitialTupleWithTypeEncodedNTTPs,
            LocalInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I1<UnusedType, std::enable_if_t<(kEnabledIteration >= 1), void>> {
        static constexpr FunctorOutputType kPriorOutput = I0<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

// Forward-declare iteration structs for partial template specialization
      // SFINAE
      template <typename UnusedType = void, typename Picker = void>
      struct I0;
      template <typename UnusedType = void, typename Picker = void>
      struct I1;
      template <typename UnusedType = void, typename Picker = void>
      struct I2;
      template <typename UnusedType = void, typename Picker = void>
      struct I3;
      template <typename UnusedType = void, typename Picker = void>
      struct I4;
      template <typename UnusedType = void, typename Picker = void>
      struct I5;
      template <typename UnusedType = void, typename Picker = void>
      struct I6;
      template <typename UnusedType = void, typename Picker = void>
      struct I7;
      template <typename UnusedType = void, typename Picker = void>
      struct I8;
      template <typename UnusedType = void, typename Picker = void>
      struct I9;
  
      template <typename UnusedType>
      struct I0<UnusedType, std::enable_if_t<(kEnabledIteration >= -1), void>> {
        // NOLINTNEXTLINE(readability-identifier-naming)
        static constexpr auto kValue = LinearExpansion5<
           LocalStart + (Inc * 0),
            LocalInitialTupleWithTypeEncodedNTTPs,
            LocalInitialNonCEXDataFunctor>::func();
      };
      template <typename UnusedType>
      struct I1<UnusedType, std::enable_if_t<(kEnabledIteration >= 1), void>> {
        static constexpr FunctorOutputType kPriorOutput = I0<>::kValue;

struct NextInitialNonCEXDataFunctor {
          // NOLINTNEXTLINE(readability-identifier-naming)
          static constexpr FunctorData value = std::get<0>(kPriorOutput);
        };

template <typename BodyFunctor>
struct NAryTreeCEXForLoop<BodyFunctor, 3> {
  template <typename IType, IType Start, IType End, IType Inc,
            typename BoolExpressionFunctor,
            typename InitialTupleWithTypeEncodedNTTPs,
            typename InitialNonCEXDataFunctor>
  class With {
   private:
    using FunctorData = typename BodyFunctor::NonConstexprData;
    using FunctorOutputType = typename BodyFunctor::OutputType;