#include <iostream>
#include <type_traits>
 
template< typename T, T... VALUES  > struct seq_c { using value_type = T ; };
 
template< typename T, T... > struct size ;
template< typename T, T... VALUES > struct size< seq_c< T, VALUES...> >
{ static constexpr std::size_t value = sizeof...(VALUES) ; } ;
 
template< typename T > struct pop_front {} ;
template< typename T, T V, T... VALUES > struct pop_front< seq_c< T, V, VALUES...> >
{ using type = seq_c< T, VALUES...> ; } ;
 
template< std::size_t N, typename T  > struct at {} ;
template< std::size_t N, typename T, T V, T... VALUES > struct at< N, seq_c< T, V, VALUES...> >
{ static constexpr T value = at<N-1, typename pop_front< seq_c< T, V, VALUES...> >::type >::value ; } ;
template< typename T, T V, T... VALUES > struct at< 0, seq_c< T, V, VALUES...> >
{ static constexpr T value = V ; } ;
template< typename T  > struct front
{ static constexpr typename T::value_type value = at<0,T>::value ; } ;
 
template< typename T, T V, typename U > struct push_back {} ;
template< typename T, T V > struct push_back< T, V, seq_c<T> >
{ using type = seq_c<T,V> ; } ;
template< typename T, T V, T... VALUES > struct push_back< T, V, seq_c< T, VALUES...> >
{ using type = seq_c< T, VALUES..., V > ; } ;
 
template < typename T, typename U, std::size_t N = size<T>::value > struct paiwise_sum
{
    using common_type = typename std::common_type< typename T::value_type,
                                                   typename U::value_type >::type ;
    using type =  typename push_back<
                         common_type,
                         front<T>::value + front<U>::value,
                         typename paiwise_sum< typename pop_front<T>::type,
                                               typename pop_front<U>::type >::type >::type ;
};
template < typename T, typename U > struct paiwise_sum<T,U,0>
{
    using type = seq_c< typename std::common_type< typename T::value_type,
                                                   typename U::value_type >::type > ; };
 
template < typename T, T A, T B > struct max
{ static constexpr T value = A < B ? B : A ; } ;
template< typename T > struct max_element {};
template< typename T, T V, T... VALUES > struct max_element< seq_c< T, V, VALUES...> >
{
    using value_type = typename seq_c< T, V, VALUES...>::value_type ;
    static constexpr T value = max< T, V, max_element< seq_c< T, VALUES...> >::value >::value ;
} ;
template< typename T, T V > struct max_element< seq_c< T, V > > { static constexpr T value = V ; } ;
 
template < typename T > struct print {} ;
template < typename T > struct print< seq_c<T> > {};
template< typename T, T V, T... VALUES >
struct print< seq_c< T, V, VALUES...> > : print< seq_c<T,VALUES...> >
{ print() { std::cout << V << ' ' ; } } ;
 
int main()
{
    using a = seq_c< long long , 10, 20, 30, 40, 50 > ;
    using b = seq_c< int, -1, -17, -23, 0, -45 > ;
    using c = paiwise_sum<a,b>::type ;
    print<c>{} ;
    std::cout << "  max: " << max_element<c>::value << '\n' ;
}
 

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