namespace IntegralList
{
template <typename T, T... Series>
struct List {};

template <typename T, T... Head, T... Tail>
List<T, Head..., Tail...> Append(List<T, Head...>, List<T, Tail...>);

namespace Private
{
    template <typename T>
    constexpr bool is_empty_list(T Begin, T End, T Step)
    {
        return (End * Step) <= (Begin * Step);
    }
}

template <typename T, T Begin, T End, T Step, bool Empty = false>
struct MakeIntegralSeriesImpl
{
    using Type = typename std::conditional<Private::is_empty_list(Begin, End, Step),
                                           List<T>,
                                           decltype(Append(std::declval<List<T, Begin>>(),
                                                    typename MakeIntegralSeriesImpl<T, Begin + Step, End, Step, Private::is_empty_list(Begin, End, Step)>::Type()))>::type;
};

template <typename T, T Begin, T End, T Step>
struct MakeIntegralSeriesImpl<T, Begin, End, Step, true>
{
    using Type = List<T>;
};

}

template <template<std::size_t> class T, typename... Args>
struct Multiplex
{
    std::size_t n;
    const std::tuple<Args...> &args;
};

template <std::size_t Max>
struct MultiplexingModule
{
    template<typename Messenger, template<std::size_t> class T, typename... Args>
    std::tuple<> process_message(const Messenger& messenger, const Multiplex<T, Args...> &message)
    {
        generate_message_and_pass_message<Messenger, T, Args...>(typename IntegralList::MakeIntegralSeriesImpl<std::size_t, 0, sizeof...(Args), 1>::Type(),
                                                                 typename IntegralList::MakeIntegralSeriesImpl<std::size_t, 0, Max, 1>::Type(),
                                                                 message.n, messenger, message.args);
        return std::make_tuple();
    }
    private:

    template<typename Messenger, template<std::size_t> class T,  typename... Args, std::size_t... ArgsIndices, std::size_t... FuncIndices>
    static void generate_message_and_pass_message(IntegralList::List<std::size_t, ArgsIndices...>,
                                                  IntegralList::List<std::size_t, FuncIndices...>,
                                                  const std::size_t n, const Messenger &messenger, const std::tuple<Args...> &args)
    {
        constexpr void(*func_array[])(const Messenger &messenger, Args... args) = {generate_message_and_pass_message<FuncIndices, Messenger, T, Args...>...};
        func_array[n](messenger, std::forward<typename std::tuple_element<ArgsIndices, const std::tuple<Args...>>::type>(std::get<ArgsIndices>(args))...);
    }

    template<std::size_t N, typename Messenger, template<std::size_t> class T,  typename... Args>
    static void generate_message_and_pass_message(const Messenger &messenger, Args... args)
    {
        messenger.pass_message(T<N>(std::forward<Args>(args)...));
    }
};

template <std::size_t N>
struct Foo
{
    Foo(int n, int i1, int i2, int i3, int i4)
    {
        std::cout<< "Foo " << N << " was constructed with " << n << i1 << i2 << i3 << i4 << std::endl;
    };
};

int main()
{
    volatile std::size_t i = 0;
    int b;
    Messenger::Messenger<MultiplexingModule<500>> messenger;
    messenger.pass_message(Multiplex<Foo, int&, int, int, int, int>{i, {b, 0, 0, 1, 2}});
    return 0;
}