template <typename...>
struct is_one_of
{
   static constexpr bool value = false;
};

template <typename F, typename S, typename... T>
struct is_one_of<F, S, T...>
{
   static constexpr bool value =
       std::is_same<F, S>::value || is_one_of<F, T...>::value;
};

template <typename T>
class Average
{
public:
   T x;
};

struct dummy_tag{};
template <>
class Average<dummy_tag>
{
};


using SizeT = std::size_t;

template class Average<int32_t>;
template class Average<int64_t>;
template class Average<uint32_t>;
template class Average<uint64_t>;
template class Average<
   std::conditional_t<
   is_one_of<SizeT, int32_t, int64_t, uint32_t, uint64_t>::value, dummy_tag, SizeT>>;

template <typename T>
class Average
{
public:
   T x;
};

template <>
class Average
{
};

using SizeT = std::size_t;

constexpr bool isSizeSigned = std::is_signed::value;
using CollidingInt32 = std::conditional_t<isSizeSigned, int32_t, uint32_t>;
using CollidingInt64 = std::conditional_t<isSizeSigned, int64_t, uint64_t>;

using NotCollidingInt32 = std::conditional_t<isSizeSigned, uint32_t, int32_t>;
using NotCollidingInt64 = std::conditional_t<isSizeSigned, uint64_t, int64_t>;

constexpr bool collisionWithUint32 = std::is_same<CollidingInt32, SizeT>::value;
constexpr bool collisionWithUint64 = std::is_same<CollidingInt64, SizeT>::value;
using SizeOrCollidingInt32 = std::conditional_t<collisionWithUint32, SizeT, CollidingInt32>;
using SizeOrCollidingInt64 = std::conditional_t<collisionWithUint64, SizeT, CollidingInt64>;
using SizeOrVoid = std::conditional_t<collisionWithUint32 || collisionWithUint64, void, SizeT>;

template class Average;
template class Average;
template class Average;
template class Average;…