Multiple void_t calls in template specializations

The first thing I need help with is to resolve the ambiguity below. But once the ambiguity is gone, I still need to know if there is a more concise and elegant way to implement the 8 specializations.

#include <iostream>

template <typename>
using void_t = void;

template <typename T, typename U, typename = void, typename = void, typename = void>
struct Foo {
    static void call() {std::cout << "Case 1\n";}
};

template <typename T, typename U>
struct Foo<T, U,
        void_t<decltype(std::declval<T>().foo(int()))>,
        void_t<decltype(std::declval<U>().bar(bool(), char()))>,
        void_t<decltype(execute(std::declval<const T&>(), std::declval<const U&>()))>> {
    static void call() {std::cout << "Case 2\n";}
};

template <typename T, typename U>
struct Foo<T, U,
        void_t<decltype(std::declval<T>().foo(int()))>,
        void, void> {
    static void call() {std::cout << "Case 3\n";}
};
// etc... for the remaining 5 specializations.

struct Thing {
    void foo(int) {}
};

struct Uber {
    int bar(bool, char) {return 2;}
};

void execute (const Thing&, const Uber&) {}

int main() {
    Foo<Thing, int>::call();  // Case 3
//  Foo<Thing, Uber>::call();  // Ambiguous.  Want this to be "Case 2" instead of "Case 3".
}

So first, I need to know why Foo<Thing, Uber>::call(); is ambiguous. All 3 void_t's are fulfilled, so isn't Case 2 more specialized than Case 3? Also, I intend to have 5 more specializations for the 2x2x2 possibilities of the 3 void_t's being fulfilled or not fulfilled. What is the most elegant way to handle 2^n such specializations if there were n void_t's being used?

As an analogy, for the case of handling 3 std::enable_if_t calls like

#include <iostream>
#include <type_traits>

template <bool B> using bool_constant = std::integral_constant<bool, B>;

template <std::size_t N>
struct is_even : bool_constant<N % 2 == 0> {};

template <std::size_t N, std::size_t A>
struct add_to_odd : bool_constant<(N + A) % 2 == 1> {};

template <std::size_t N, std::size_t A, std::size_t B>
struct is_one_of_these : bool_constant<N == A || N == B> {};

template <std::size_t N, std::size_t A, std::size_t B, typename = void, typename = void, typename = void>
struct Foo {
    static void call() {std::cout << "Case 1\n";}
};

template <std::size_t N, std::size_t A, std::size_t B>
struct Foo<N,A,B,
        std::enable_if_t<is_even<N>::value>, 
        std::enable_if_t<!add_to_odd<N,A>::value>, 
        std::enable_if_t<!is_one_of_these<N,A,B>::value>> {
    static void call() {std::cout << "Case 2\n";}
};

// etc... for the other combinations of the 3 enable_if conditions being true/false.

int main() {
    Foo<1,2,3>::call();
    Foo<8,2,3>::call();
}

I figured out

#include <iostream>
#include <type_traits>

template <bool B> using bool_constant = std::integral_constant<bool, B>;

template <std::size_t N>
struct is_even : bool_constant<N % 2 == 0> {};

template <std::size_t N, std::size_t A>
struct add_to_odd : bool_constant<(N + A) % 2 == 1> {};

template <std::size_t N, std::size_t A, std::size_t B>
struct is_one_of_these : bool_constant<N == A || N == B> {};

template <std::size_t N, std::size_t A, std::size_t B, bool, bool, bool>
struct FooHelper {
    static void call() {std::cout << "Case 1\n";}
};

template <std::size_t N, std::size_t A, std::size_t B>
struct FooHelper<N, A, B, true, false, false> {
    static void call() {std::cout << "Case 2\n";}
};

template <std::size_t N, std::size_t A, std::size_t B>
struct FooHelper<N, A, B, true, true, false> {
    static void call() {std::cout << "Case 3\n";}
};

template <std::size_t N, std::size_t A, std::size_t B>
struct FooHelper<N, A, B, true, true, true> {
    static void call() {std::cout << "Case 4\n";}
};

template <std::size_t N, std::size_t A, std::size_t B>
struct FooHelper<N, A, B, false, true, true> {
    static void call() {std::cout << "Case 5\n";}
};

template <std::size_t N, std::size_t A, std::size_t B>
struct FooHelper<N, A, B, false, false, true> {
    static void call() {std::cout << "Case 6\n";}
};

template <std::size_t N, std::size_t A, std::size_t B>
struct FooHelper<N, A, B, true, false, true> {
    static void call() {std::cout << "Case 7\n";}
};

template <std::size_t N, std::size_t A, std::size_t B>
struct FooHelper<N, A, B, false, true, false> {
    static void call() {std::cout << "Case 8\n";}
};

template <std::size_t N, std::size_t A, std::size_t B>
struct Foo : FooHelper<N, A, B, is_even<N>::value, add_to_odd<N,A>::value, is_one_of_these<N,A,B>::value> {};

int main() {
    Foo<1,2,3>::call();
    Foo<8,2,3>::call();
    // etc...
}

to make the 8 template specializations more concise and easier to read. But the analogy for n void_t's is not so obvious to me (well, the above ambiguity doesn't really help either).