Type mismatch of pointer to template member function

I am following this code snippet which makes it easier to pass a member function to an interface expecting a C-style callback (that is, the interface expects a function pointer to the callback, and a void* pointer to user data which will in turn be passed to the callback). Effectively I want to convert Helper::M to Helper::V below.

I am trying to modify the snippet to automatically deduce the template parameters. Here is my current attempt.

#include <iostream>

template <typename R, typename T, typename... Args>
struct Helper {
  using V = R (*)(void*, Args...);
  using M = R (T::*)(Args...);
  template <M m>
  static R Fn(void* data, Args... args) {
    return (static_cast<T*>(data)->*m)(std::forward<Args...>(args...));
  }
};

template <typename R, typename T, typename... Args>
typename Helper<R, T, Args...>::V Cast(R (T::*m)(Args...)) {
  return Helper<R, T, Args...>::template Fn<m>;
}

int CIntf(void* data, int (*f)(void*, int)) { return f(data, 1); }

struct UserData {
  int x;
  int Add(int y) { return x + y; }
};

int main(int argv, char** argc) {
  UserData data = {4};
  // Explicit parameters; works.
  std::cout << CIntf(&data, Helper<int, UserData, int>::Fn<&UserData::Add>)
            << "\n";
  // Deduced parameters; fails.
  std::cout << CIntf(&data, Cast(&UserData::Add)) << "\n";

  return 0;
}

I tried to compile with gcc -std=c++11 -lstdc++. The explicit parameters method works fine, but the deduced parameters method gives the following error:

tmp.cc: In instantiation of ‘typename Helper<R, T, Args>::V Cast(R (T::*)(Args ...)) [with R = int; T = UserData; Args = {int}; typename Helper<R, T, Args>::V = int (*)(void*, int)]’:
tmp.cc:30:58:   required from here
tmp.cc:15:42: error: no matches converting function ‘Fn’ to type ‘using V = int (*)(void*, int) {aka int (*)(void*, int)}’
   return Helper<R, T, Args...>::template Fn<m>;
                                          ^~~~~
tmp.cc:8:12: note: candidate is: template<int (UserData::* m)(int)> static R Helper<R, T, Args>::Fn(void*, Args ...) [with R (T::* m)(Args ...) = m; R = int; T = UserData; Args = {int}]
   static R Fn(void* data, Args... args) {

Note that it correctly deduced the template parameters, but failed to convert Helper<int, UserData, int>::Fn<m> to int (*)(void*, int); why? This same conversion succeeded in the explicit case (unless m is somehow different from &UserData::Add).