#include <iostream>
#include <type_traits>

// First of all we need something what can give us type of Nth element:
template <size_t Pos, class T, class... TElements>
struct TGetTypeOfNthElement {
    using TResult = typename TGetTypeOfNthElement<Pos - 1, TElements...>::TResult;
};
template <class T, class... TElements> // If Pos == 0
struct TGetTypeOfNthElement<0, T, TElements...> {
    using TResult = T;
};



// Now, when we can get type by its position, we can write function which returns value by position:
// We are using SFINAE here, because we can not just write it
// typename TGetTypeOfNthElement<Pos, T, TElements...>::TResult GetNthElement(T t, TElements... Elements) {
//     if(Pos == 0) return t;
//     else return GetNthElement<Pos - 1>(Elements...);
// }
// because compiler will try to instantiate this frunction with Pos == 0 and get GetNthElement<0 - 1> and will fail
template<size_t Pos, class T, class... TElements, class = typename std::enable_if<Pos == 0>::type>
T GetNthElement(T t, TElements... /*Elements*/) {
    return t;
}
template<size_t Pos, class T, class... TElements, class = typename std::enable_if<Pos != 0>::type>
typename TGetTypeOfNthElement<Pos, T, TElements...>::TResult GetNthElement(T t, TElements... Elements) {
    //UNUSED(t);
    return GetNthElement<Pos - 1>(Elements...);
}


// Finally we need to generate sequence of indeces, to pick up values in needed order.
// In particular for this example
// LetsStart<int, -1, 10, 3>("This is -1", "And this is 10", "3!!!");
// following code will generate TSequence<0, 3, 1, 4, 2, 5>
template<size_t ...Positions>
class TSequence {};
template <size_t MaxN, size_t i, size_t... AlreadyGeneratedNumbers>
struct TGenerateSequence {
    using TResult = typename TGenerateSequence<MaxN, i + 1, AlreadyGeneratedNumbers..., i, i + MaxN>::TResult;
};
template <size_t MaxN, size_t... AlreadyGeneratedNumbers>
struct TGenerateSequence<MaxN, MaxN, AlreadyGeneratedNumbers...> {
    using TResult = TSequence<AlreadyGeneratedNumbers...>;
};



// Functions which will split values by two onces from pack and output it
template<class TV, class TD>
void Output(TV V, TD D) {
    std::cout << V << " " << D << std::endl;
}
template<class TV, class TD, class ...TOther>
void Output(TV V, TD D, TOther... Other) {
    Output(V, D);
    Output(Other...);
}


// Main entry point
template<size_t... Indeces, class ...TElements>
void LetsStart2(TSequence<Indeces...>, TElements... Elements) {
    Output(GetNthElement<Indeces>(Elements...)...);
}
template<class TV, TV ...TVs, class ...TD>
void LetsStart(TD...Ds) {
    LetsStart2(typename TGenerateSequence<sizeof...(TVs), 0>::TResult(), TVs..., Ds...);
}


int main() {
    LetsStart<int, -1, 10, 3>("This is -1", "And this is 10", "3!!!");
    return 0;
}