Update legacy Tuple-using code.

BUG=440675
TEST=no change
R=mdempsky@chromium.org, nasko@chromium.org
TBR=ben@chromium.org

Review URL: https://codereview.chromium.org/814403003

Cr-Commit-Position: refs/heads/master@{#309432}

7 files changed, 1580 insertions, 1590 deletions

diff --git a/chrome/common/chrome_utility_messages.h b/chrome/common/chrome_utility_messages.h
index b0d0eb2..b276d38 100644
--- a/chrome/common/chrome_utility_messages.h
+++ b/chrome/common/chrome_utility_messages.h
@@ -26,7 +26,7 @@
 #ifndef CHROME_COMMON_CHROME_UTILITY_MESSAGES_H_
 #define CHROME_COMMON_CHROME_UTILITY_MESSAGES_H_
 
-typedef std::vector<Tuple2<SkBitmap, base::FilePath> > DecodedImages;
+typedef std::vector<Tuple<SkBitmap, base::FilePath>> DecodedImages;
 
 #endif  // CHROME_COMMON_CHROME_UTILITY_MESSAGES_H_
 
@@ -38,9 +38,9 @@ IPC_STRUCT_TRAITS_END()
 
 #if defined(OS_WIN)
 
-// A vector of filters, each being a Tuple2 containing a display string (i.e.
+// A vector of filters, each being a Tuple containing a display string (i.e.
 // "Text Files") and a filter pattern (i.e. "*.txt").
-typedef std::vector<Tuple2<base::string16, base::string16> >
+typedef std::vector<Tuple<base::string16, base::string16>>
     GetOpenFileNameFilter;
 
 IPC_STRUCT_BEGIN(ChromeUtilityMsg_GetSaveFileName_Params)
diff --git a/ipc/ipc_message_macros.h b/ipc/ipc_message_macros.h
index 20c8335..01789cb 100644
--- a/ipc/ipc_message_macros.h
+++ b/ipc/ipc_message_macros.h
@@ -457,7 +457,7 @@
                        void (T::*func)(P*, TA)) {                             \
     Schema::Param p;                                                          \
     if (Read(msg, &p)) {                                                      \
-      (obj->*func)(parameter, p.a);                                           \
+      (obj->*func)(parameter, get<0>(p));                                     \
       return true;                                                            \
     }                                                                         \
     return false;                                                             \
@@ -469,7 +469,7 @@
                        void (T::*func)(P*, TA, TB)) {                         \
     Schema::Param p;                                                          \
     if (Read(msg, &p)) {                                                      \
-      (obj->*func)(parameter, p.a, p.b);                                      \
+      (obj->*func)(parameter, get<0>(p), get<1>(p));                          \
       return true;                                                            \
     }                                                                         \
     return false;                                                             \
@@ -481,7 +481,7 @@
                        void (T::*func)(P*, TA, TB, TC)) {                     \
     Schema::Param p;                                                          \
     if (Read(msg, &p)) {                                                      \
-      (obj->*func)(parameter, p.a, p.b, p.c);                                 \
+      (obj->*func)(parameter, get<0>(p), get<1>(p), get<2>(p));               \
       return true;                                                            \
     }                                                                         \
     return false;                                                             \
@@ -494,7 +494,7 @@
                        void (T::*func)(P*, TA, TB, TC, TD)) {                 \
     Schema::Param p;                                                          \
     if (Read(msg, &p)) {                                                      \
-      (obj->*func)(parameter, p.a, p.b, p.c, p.d);                            \
+      (obj->*func)(parameter, get<0>(p), get<1>(p), get<2>(p), get<3>(p));    \
       return true;                                                            \
     }                                                                         \
     return false;                                                             \
@@ -507,7 +507,8 @@
                        void (T::*func)(P*, TA, TB, TC, TD, TE)) {             \
     Schema::Param p;                                                          \
     if (Read(msg, &p)) {                                                      \
-      (obj->*func)(parameter, p.a, p.b, p.c, p.d, p.e);                       \
+      (obj->*func)(parameter, get<0>(p), get<1>(p), get<2>(p), get<3>(p),     \
+                   get<4>(p));                                                \
       return true;                                                            \
     }                                                                         \
     return false;                                                             \
@@ -817,18 +818,18 @@
 #define IPC_TYPE_OUT_3(t1, t2, t3)          t1* arg6, t2* arg7, t3* arg8
 #define IPC_TYPE_OUT_4(t1, t2, t3, t4)      t1* arg6, t2* arg7, t3* arg8, t4* arg9
 
-#define IPC_TUPLE_IN_0()                    Tuple0
-#define IPC_TUPLE_IN_1(t1)                  Tuple1<t1>
-#define IPC_TUPLE_IN_2(t1, t2)              Tuple2<t1, t2>
-#define IPC_TUPLE_IN_3(t1, t2, t3)          Tuple3<t1, t2, t3>
-#define IPC_TUPLE_IN_4(t1, t2, t3, t4)      Tuple4<t1, t2, t3, t4>
-#define IPC_TUPLE_IN_5(t1, t2, t3, t4, t5)  Tuple5<t1, t2, t3, t4, t5>
-
-#define IPC_TUPLE_OUT_0()                   Tuple0
-#define IPC_TUPLE_OUT_1(t1)                 Tuple1<t1&>
-#define IPC_TUPLE_OUT_2(t1, t2)             Tuple2<t1&, t2&>
-#define IPC_TUPLE_OUT_3(t1, t2, t3)         Tuple3<t1&, t2&, t3&>
-#define IPC_TUPLE_OUT_4(t1, t2, t3, t4)     Tuple4<t1&, t2&, t3&, t4&>
+#define IPC_TUPLE_IN_0()                    Tuple<>
+#define IPC_TUPLE_IN_1(t1)                  Tuple<t1>
+#define IPC_TUPLE_IN_2(t1, t2)              Tuple<t1, t2>
+#define IPC_TUPLE_IN_3(t1, t2, t3)          Tuple<t1, t2, t3>
+#define IPC_TUPLE_IN_4(t1, t2, t3, t4)      Tuple<t1, t2, t3, t4>
+#define IPC_TUPLE_IN_5(t1, t2, t3, t4, t5)  Tuple<t1, t2, t3, t4, t5>
+
+#define IPC_TUPLE_OUT_0()                   Tuple<>
+#define IPC_TUPLE_OUT_1(t1)                 Tuple<t1&>
+#define IPC_TUPLE_OUT_2(t1, t2)             Tuple<t1&, t2&>
+#define IPC_TUPLE_OUT_3(t1, t2, t3)         Tuple<t1&, t2&, t3&>
+#define IPC_TUPLE_OUT_4(t1, t2, t3, t4)     Tuple<t1&, t2&, t3&, t4&>
 
 #define IPC_NAME_IN_0()                     MakeTuple()
 #define IPC_NAME_IN_1(t1)                   MakeRefTuple(arg1)
diff --git a/ipc/ipc_message_utils.h b/ipc/ipc_message_utils.h
index 92351a6..d18ab61 100644
--- a/ipc/ipc_message_utils.h
+++ b/ipc/ipc_message_utils.h
@@ -520,8 +520,8 @@ struct IPC_EXPORT ParamTraits<base::TimeTicks> {
 };
 
 template <>
-struct ParamTraits<Tuple0> {
-  typedef Tuple0 param_type;
+struct ParamTraits<Tuple<>> {
+  typedef Tuple<> param_type;
   static void Write(Message* m, const param_type& p) {
   }
   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
@@ -532,112 +532,112 @@ struct ParamTraits<Tuple0> {
 };
 
 template <class A>
-struct ParamTraits< Tuple1<A> > {
-  typedef Tuple1<A> param_type;
+struct ParamTraits<Tuple<A>> {
+  typedef Tuple<A> param_type;
   static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.a);
+    WriteParam(m, get<0>(p));
   }
   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
-    return ReadParam(m, iter, &r->a);
+    return ReadParam(m, iter, &get<0>(*r));
   }
   static void Log(const param_type& p, std::string* l) {
-    LogParam(p.a, l);
+    LogParam(get<0>(p), l);
   }
 };
 
 template <class A, class B>
-struct ParamTraits< Tuple2<A, B> > {
-  typedef Tuple2<A, B> param_type;
+struct ParamTraits< Tuple<A, B> > {
+  typedef Tuple<A, B> param_type;
   static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.a);
-    WriteParam(m, p.b);
+    WriteParam(m, get<0>(p));
+    WriteParam(m, get<1>(p));
   }
   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
-    return (ReadParam(m, iter, &r->a) &&
-            ReadParam(m, iter, &r->b));
+    return (ReadParam(m, iter, &get<0>(*r)) &&
+            ReadParam(m, iter, &get<1>(*r)));
   }
   static void Log(const param_type& p, std::string* l) {
-    LogParam(p.a, l);
+    LogParam(get<0>(p), l);
     l->append(", ");
-    LogParam(p.b, l);
+    LogParam(get<1>(p), l);
   }
 };
 
 template <class A, class B, class C>
-struct ParamTraits< Tuple3<A, B, C> > {
-  typedef Tuple3<A, B, C> param_type;
+struct ParamTraits< Tuple<A, B, C> > {
+  typedef Tuple<A, B, C> param_type;
   static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.a);
-    WriteParam(m, p.b);
-    WriteParam(m, p.c);
+    WriteParam(m, get<0>(p));
+    WriteParam(m, get<1>(p));
+    WriteParam(m, get<2>(p));
   }
   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
-    return (ReadParam(m, iter, &r->a) &&
-            ReadParam(m, iter, &r->b) &&
-            ReadParam(m, iter, &r->c));
+    return (ReadParam(m, iter, &get<0>(*r)) &&
+            ReadParam(m, iter, &get<1>(*r)) &&
+            ReadParam(m, iter, &get<2>(*r)));
   }
   static void Log(const param_type& p, std::string* l) {
-    LogParam(p.a, l);
+    LogParam(get<0>(p), l);
     l->append(", ");
-    LogParam(p.b, l);
+    LogParam(get<1>(p), l);
     l->append(", ");
-    LogParam(p.c, l);
+    LogParam(get<2>(p), l);
   }
 };
 
 template <class A, class B, class C, class D>
-struct ParamTraits< Tuple4<A, B, C, D> > {
-  typedef Tuple4<A, B, C, D> param_type;
+struct ParamTraits< Tuple<A, B, C, D> > {
+  typedef Tuple<A, B, C, D> param_type;
   static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.a);
-    WriteParam(m, p.b);
-    WriteParam(m, p.c);
-    WriteParam(m, p.d);
+    WriteParam(m, get<0>(p));
+    WriteParam(m, get<1>(p));
+    WriteParam(m, get<2>(p));
+    WriteParam(m, get<3>(p));
   }
   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
-    return (ReadParam(m, iter, &r->a) &&
-            ReadParam(m, iter, &r->b) &&
-            ReadParam(m, iter, &r->c) &&
-            ReadParam(m, iter, &r->d));
+    return (ReadParam(m, iter, &get<0>(*r)) &&
+            ReadParam(m, iter, &get<1>(*r)) &&
+            ReadParam(m, iter, &get<2>(*r)) &&
+            ReadParam(m, iter, &get<3>(*r)));
   }
   static void Log(const param_type& p, std::string* l) {
-    LogParam(p.a, l);
+    LogParam(get<0>(p), l);
     l->append(", ");
-    LogParam(p.b, l);
+    LogParam(get<1>(p), l);
     l->append(", ");
-    LogParam(p.c, l);
+    LogParam(get<2>(p), l);
     l->append(", ");
-    LogParam(p.d, l);
+    LogParam(get<3>(p), l);
   }
 };
 
 template <class A, class B, class C, class D, class E>
-struct ParamTraits< Tuple5<A, B, C, D, E> > {
-  typedef Tuple5<A, B, C, D, E> param_type;
+struct ParamTraits< Tuple<A, B, C, D, E> > {
+  typedef Tuple<A, B, C, D, E> param_type;
   static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.a);
-    WriteParam(m, p.b);
-    WriteParam(m, p.c);
-    WriteParam(m, p.d);
-    WriteParam(m, p.e);
+    WriteParam(m, get<0>(p));
+    WriteParam(m, get<1>(p));
+    WriteParam(m, get<2>(p));
+    WriteParam(m, get<3>(p));
+    WriteParam(m, get<4>(p));
   }
   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
-    return (ReadParam(m, iter, &r->a) &&
-            ReadParam(m, iter, &r->b) &&
-            ReadParam(m, iter, &r->c) &&
-            ReadParam(m, iter, &r->d) &&
-            ReadParam(m, iter, &r->e));
+    return (ReadParam(m, iter, &get<0>(*r)) &&
+            ReadParam(m, iter, &get<1>(*r)) &&
+            ReadParam(m, iter, &get<2>(*r)) &&
+            ReadParam(m, iter, &get<3>(*r)) &&
+            ReadParam(m, iter, &get<4>(*r)));
   }
   static void Log(const param_type& p, std::string* l) {
-    LogParam(p.a, l);
+    LogParam(get<0>(p), l);
     l->append(", ");
-    LogParam(p.b, l);
+    LogParam(get<1>(p), l);
     l->append(", ");
-    LogParam(p.c, l);
+    LogParam(get<2>(p), l);
     l->append(", ");
-    LogParam(p.d, l);
+    LogParam(get<3>(p), l);
     l->append(", ");
-    LogParam(p.e, l);
+    LogParam(get<4>(p), l);
   }
 };
 
@@ -912,7 +912,7 @@ class SyncMessageSchema {
                                                Method func) {
     Message* reply = SyncMessage::GenerateReply(msg);
     if (ok) {
-      Tuple1<Message&> t = MakeRefTuple(*reply);
+      Tuple<Message&> t = MakeRefTuple(*reply);
       ConnectMessageAndReply(msg, reply);
       DispatchToMethod(obj, func, send_params, &t);
     } else {
diff --git a/sandbox/linux/seccomp-bpf/codegen.cc b/sandbox/linux/seccomp-bpf/codegen.cc
index df967601..055aa71 100644
--- a/sandbox/linux/seccomp-bpf/codegen.cc
+++ b/sandbox/linux/seccomp-bpf/codegen.cc
@@ -145,14 +145,14 @@ size_t CodeGen::Offset(Node target) const {
 // TODO(mdempsky): Move into a general base::Tuple helper library.
 bool CodeGen::MemoKeyLess::operator()(const MemoKey& lhs,
                                       const MemoKey& rhs) const {
-  if (lhs.a != rhs.a)
-    return lhs.a < rhs.a;
-  if (lhs.b != rhs.b)
-    return lhs.b < rhs.b;
-  if (lhs.c != rhs.c)
-    return lhs.c < rhs.c;
-  if (lhs.d != rhs.d)
-    return lhs.d < rhs.d;
+  if (get<0>(lhs) != get<0>(rhs))
+    return get<0>(lhs) < get<0>(rhs);
+  if (get<1>(lhs) != get<1>(rhs))
+    return get<1>(lhs) < get<1>(rhs);
+  if (get<2>(lhs) != get<2>(rhs))
+    return get<2>(lhs) < get<2>(rhs);
+  if (get<3>(lhs) != get<3>(rhs))
+    return get<3>(lhs) < get<3>(rhs);
   return false;
 }
 
diff --git a/sandbox/linux/seccomp-bpf/codegen.h b/sandbox/linux/seccomp-bpf/codegen.h
index e679664..ef04a5d 100644
--- a/sandbox/linux/seccomp-bpf/codegen.h
+++ b/sandbox/linux/seccomp-bpf/codegen.h
@@ -81,7 +81,7 @@ class SANDBOX_EXPORT CodeGen {
   void Compile(Node head, Program* program);
 
  private:
-  using MemoKey = Tuple4<uint16_t, uint32_t, Node, Node>;
+  using MemoKey = Tuple<uint16_t, uint32_t, Node, Node>;
   struct MemoKeyLess {
     bool operator()(const MemoKey& lhs, const MemoKey& rhs) const;
   };
diff --git a/testing/generate_gmock_mutant.py b/testing/generate_gmock_mutant.py
index 6d814f0..a6ee4c3 100755
--- a/testing/generate_gmock_mutant.py
+++ b/testing/generate_gmock_mutant.py
@@ -56,8 +56,8 @@ HEADER = """\
 //   }
 //
 //   void QuitMessageLoop(int seconds) {
-//     MessageLoop* loop = MessageLoop::current();
-//     loop->PostDelayedTask(FROM_HERE, MessageLoop::QuitClosure(),
+//     base::MessageLoop* loop = base::MessageLoop::current();
+//     loop->PostDelayedTask(FROM_HERE, base::MessageLoop::QuitClosure(),
 //                           1000 * seconds);
 //   }
 // };
@@ -202,7 +202,7 @@ struct MutantFunctor {
   }
 
   inline R operator()() {
-    return impl_->RunWithParams(Tuple0());
+    return impl_->RunWithParams(Tuple<>());
   }
 
   template <typename Arg1>
@@ -241,8 +241,8 @@ FOOTER = """\
 
 # Templates for DispatchToMethod/DispatchToFunction functions.
 # template_params - typename P1, typename P2.. typename C1..
-# prebound - TupleN<P1, .. PN>
-# calltime - TupleN<C1, .. CN>
+# prebound - Tuple<P1, .. PN>
+# calltime - Tuple<C1, .. CN>
 # args - p.a, p.b.., c.a, c.b..
 DISPATCH_TO_METHOD_TEMPLATE = """\
 template <typename R, typename T, typename Method, %(template_params)s>
@@ -264,8 +264,8 @@ inline R DispatchToFunction(Function function,
 
 # Templates for CreateFunctor functions.
 # template_params - typename P1, typename P2.. typename C1.. typename X1..
-# prebound - TupleN<P1, .. PN>
-# calltime - TupleN<A1, .. AN>
+# prebound - Tuple<P1, .. PN>
+# calltime - Tuple<A1, .. AN>
 # params - X1,.. , A1, ..
 # args - const P1& p1 ..
 # call_args - p1, p2, p3..
@@ -305,7 +305,7 @@ def SplitLine(line, width):
   return (line[:n], line[n + 1:])
 
 
-def Wrap(s, width, subsequent_offset=4):
+def Wrap(s, width, subsequent_offset):
   """Wraps a single line |s| at commas so every line is at most |width|
      characters long.
   """
@@ -324,10 +324,8 @@ def Clean(s):
 
   Our simple string formatting/concatenation may introduce extra commas.
   """
-  s = s.replace("<>", "")
   s = s.replace(", >", ">")
   s = s.replace(", )", ")")
-  s = s.replace(">>", "> >")
   return s
 
 
@@ -339,23 +337,13 @@ def ExpandPattern(pattern, it):
   return [pattern.replace("%", x) for x in it]
 
 
-def Gen(pattern, n):
-  """Expands pattern replacing '%' with sequential integers.
+def Gen(pattern, n, start):
+  """Expands pattern replacing '%' with sequential integers starting with start.
 
   Expanded patterns will be joined with comma separator.
-  GenAlphs("X%", 3) will return "X1, X2, X3".
+  Gen("X%", 3, 1) will return "X1, X2, X3".
   """
-  it = string.hexdigits[1:n + 1]
-  return ", ".join(ExpandPattern(pattern, it))
-
-
-def GenAlpha(pattern, n):
-  """Expands pattern replacing '%' with sequential small ASCII letters.
-
-  Expanded patterns will be joined with comma separator.
-  GenAlphs("X%", 3) will return "Xa, Xb, Xc".
-  """
-  it = string.ascii_lowercase[0:n]
+  it = string.hexdigits[start:n + start]
   return ", ".join(ExpandPattern(pattern, it))
 
 
@@ -364,7 +352,7 @@ def Merge(a):
 
 
 def GenTuple(pattern, n):
-  return Clean("Tuple%d<%s>" % (n, Gen(pattern, n)))
+  return Clean("Tuple<%s>" % (Gen(pattern, n, 1)))
 
 
 def FixCode(s):
@@ -378,11 +366,12 @@ def FixCode(s):
 def GenerateDispatch(prebound, calltime):
   print "\n// %d - %d" % (prebound, calltime)
   args = {
-      "template_params": Merge([Gen("typename P%", prebound),
-                                Gen("typename C%", calltime)]),
+      "template_params": Merge([Gen("typename P%", prebound, 1),
+                                Gen("typename C%", calltime, 1)]),
       "prebound": GenTuple("P%", prebound),
       "calltime": GenTuple("C%", calltime),
-      "args": Merge([GenAlpha("p.%", prebound), GenAlpha("c.%", calltime)]),
+      "args": Merge([Gen("get<%>(p)", prebound, 0),
+                     Gen("get<%>(c)", calltime, 0)]),
   }
 
   print FixCode(DISPATCH_TO_METHOD_TEMPLATE % args)
@@ -394,12 +383,12 @@ def GenerateCreateFunctor(prebound, calltime):
   args = {
       "calltime": GenTuple("A%", calltime),
       "prebound": GenTuple("P%", prebound),
-      "params": Merge([Gen("X%", prebound), Gen("A%", calltime)]),
-      "args": Gen("const P%& p%", prebound),
-      "call_args": Gen("p%", prebound),
-      "template_params": Merge([Gen("typename P%", prebound),
-                                Gen("typename A%", calltime),
-                                Gen("typename X%", prebound)])
+      "params": Merge([Gen("X%", prebound, 1), Gen("A%", calltime, 1)]),
+      "args": Gen("const P%& p%", prebound, 1),
+      "call_args": Gen("p%", prebound, 1),
+      "template_params": Merge([Gen("typename P%", prebound, 1),
+                                Gen("typename A%", calltime, 1),
+                                Gen("typename X%", prebound, 1)])
   }
 
   mutant = FixCode(CREATE_METHOD_FUNCTOR_TEMPLATE % args)
diff --git a/testing/gmock_mutant.h b/testing/gmock_mutant.h
index 90d303e..964d56b 100644
--- a/testing/gmock_mutant.h
+++ b/testing/gmock_mutant.h
@@ -111,306 +111,306 @@ namespace testing {
 // 0 - 0
 template <typename R, typename T, typename Method>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple0& p,
-                          const Tuple0& c) {
+                          const Tuple<>& p,
+                          const Tuple<>& c) {
   return (obj->*method)();
 }
 template <typename R, typename Function>
 inline R DispatchToFunction(Function function,
-                            const Tuple0& p,
-                            const Tuple0& c) {
+                            const Tuple<>& p,
+                            const Tuple<>& c) {
   return (*function)();
 }
 
 // 0 - 1
 template <typename R, typename T, typename Method, typename C1>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple0& p,
-                          const Tuple1<C1>& c) {
-  return (obj->*method)(c.a);
+                          const Tuple<>& p,
+                          const Tuple<C1>& c) {
+  return (obj->*method)(get<0>(c));
 }
 template <typename R, typename Function, typename C1>
 inline R DispatchToFunction(Function function,
-                            const Tuple0& p,
-                            const Tuple1<C1>& c) {
-  return (*function)(c.a);
+                            const Tuple<>& p,
+                            const Tuple<C1>& c) {
+  return (*function)(get<0>(c));
 }
 
 // 0 - 2
 template <typename R, typename T, typename Method, typename C1, typename C2>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple0& p,
-                          const Tuple2<C1, C2>& c) {
-  return (obj->*method)(c.a, c.b);
+                          const Tuple<>& p,
+                          const Tuple<C1, C2>& c) {
+  return (obj->*method)(get<0>(c), get<1>(c));
 }
 template <typename R, typename Function, typename C1, typename C2>
 inline R DispatchToFunction(Function function,
-                            const Tuple0& p,
-                            const Tuple2<C1, C2>& c) {
-  return (*function)(c.a, c.b);
+                            const Tuple<>& p,
+                            const Tuple<C1, C2>& c) {
+  return (*function)(get<0>(c), get<1>(c));
 }
 
 // 0 - 3
 template <typename R, typename T, typename Method, typename C1, typename C2,
           typename C3>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple0& p,
-                          const Tuple3<C1, C2, C3>& c) {
-  return (obj->*method)(c.a, c.b, c.c);
+                          const Tuple<>& p,
+                          const Tuple<C1, C2, C3>& c) {
+  return (obj->*method)(get<0>(c), get<1>(c), get<2>(c));
 }
 template <typename R, typename Function, typename C1, typename C2, typename C3>
 inline R DispatchToFunction(Function function,
-                            const Tuple0& p,
-                            const Tuple3<C1, C2, C3>& c) {
-  return (*function)(c.a, c.b, c.c);
+                            const Tuple<>& p,
+                            const Tuple<C1, C2, C3>& c) {
+  return (*function)(get<0>(c), get<1>(c), get<2>(c));
 }
 
 // 0 - 4
 template <typename R, typename T, typename Method, typename C1, typename C2,
           typename C3, typename C4>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple0& p,
-                          const Tuple4<C1, C2, C3, C4>& c) {
-  return (obj->*method)(c.a, c.b, c.c, c.d);
+                          const Tuple<>& p,
+                          const Tuple<C1, C2, C3, C4>& c) {
+  return (obj->*method)(get<0>(c), get<1>(c), get<2>(c), get<3>(c));
 }
 template <typename R, typename Function, typename C1, typename C2, typename C3,
           typename C4>
 inline R DispatchToFunction(Function function,
-                            const Tuple0& p,
-                            const Tuple4<C1, C2, C3, C4>& c) {
-  return (*function)(c.a, c.b, c.c, c.d);
+                            const Tuple<>& p,
+                            const Tuple<C1, C2, C3, C4>& c) {
+  return (*function)(get<0>(c), get<1>(c), get<2>(c), get<3>(c));
 }
 
 // 0 - 5
 template <typename R, typename T, typename Method, typename C1, typename C2,
           typename C3, typename C4, typename C5>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple0& p,
-                          const Tuple5<C1, C2, C3, C4, C5>& c) {
-  return (obj->*method)(c.a, c.b, c.c, c.d, c.e);
+                          const Tuple<>& p,
+                          const Tuple<C1, C2, C3, C4, C5>& c) {
+  return (obj->*method)(get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
 }
 template <typename R, typename Function, typename C1, typename C2, typename C3,
           typename C4, typename C5>
 inline R DispatchToFunction(Function function,
-                            const Tuple0& p,
-                            const Tuple5<C1, C2, C3, C4, C5>& c) {
-  return (*function)(c.a, c.b, c.c, c.d, c.e);
+                            const Tuple<>& p,
+                            const Tuple<C1, C2, C3, C4, C5>& c) {
+  return (*function)(get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
 }
 
 // 0 - 6
 template <typename R, typename T, typename Method, typename C1, typename C2,
           typename C3, typename C4, typename C5, typename C6>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple0& p,
-                          const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
-  return (obj->*method)(c.a, c.b, c.c, c.d, c.e, c.f);
+                          const Tuple<>& p,
+                          const Tuple<C1, C2, C3, C4, C5, C6>& c) {
+  return (obj->*method)(get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
 }
 template <typename R, typename Function, typename C1, typename C2, typename C3,
           typename C4, typename C5, typename C6>
 inline R DispatchToFunction(Function function,
-                            const Tuple0& p,
-                            const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
-  return (*function)(c.a, c.b, c.c, c.d, c.e, c.f);
+                            const Tuple<>& p,
+                            const Tuple<C1, C2, C3, C4, C5, C6>& c) {
+  return (*function)(get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
 }
 
 // 1 - 0
 template <typename R, typename T, typename Method, typename P1>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple1<P1>& p,
-                          const Tuple0& c) {
-  return (obj->*method)(p.a);
+                          const Tuple<P1>& p,
+                          const Tuple<>& c) {
+  return (obj->*method)(get<0>(p));
 }
 template <typename R, typename Function, typename P1>
 inline R DispatchToFunction(Function function,
-                            const Tuple1<P1>& p,
-                            const Tuple0& c) {
-  return (*function)(p.a);
+                            const Tuple<P1>& p,
+                            const Tuple<>& c) {
+  return (*function)(get<0>(p));
 }
 
 // 1 - 1
 template <typename R, typename T, typename Method, typename P1, typename C1>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple1<P1>& p,
-                          const Tuple1<C1>& c) {
-  return (obj->*method)(p.a, c.a);
+                          const Tuple<P1>& p,
+                          const Tuple<C1>& c) {
+  return (obj->*method)(get<0>(p), get<0>(c));
 }
 template <typename R, typename Function, typename P1, typename C1>
 inline R DispatchToFunction(Function function,
-                            const Tuple1<P1>& p,
-                            const Tuple1<C1>& c) {
-  return (*function)(p.a, c.a);
+                            const Tuple<P1>& p,
+                            const Tuple<C1>& c) {
+  return (*function)(get<0>(p), get<0>(c));
 }
 
 // 1 - 2
 template <typename R, typename T, typename Method, typename P1, typename C1,
           typename C2>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple1<P1>& p,
-                          const Tuple2<C1, C2>& c) {
-  return (obj->*method)(p.a, c.a, c.b);
+                          const Tuple<P1>& p,
+                          const Tuple<C1, C2>& c) {
+  return (obj->*method)(get<0>(p), get<0>(c), get<1>(c));
 }
 template <typename R, typename Function, typename P1, typename C1, typename C2>
 inline R DispatchToFunction(Function function,
-                            const Tuple1<P1>& p,
-                            const Tuple2<C1, C2>& c) {
-  return (*function)(p.a, c.a, c.b);
+                            const Tuple<P1>& p,
+                            const Tuple<C1, C2>& c) {
+  return (*function)(get<0>(p), get<0>(c), get<1>(c));
 }
 
 // 1 - 3
 template <typename R, typename T, typename Method, typename P1, typename C1,
           typename C2, typename C3>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple1<P1>& p,
-                          const Tuple3<C1, C2, C3>& c) {
-  return (obj->*method)(p.a, c.a, c.b, c.c);
+                          const Tuple<P1>& p,
+                          const Tuple<C1, C2, C3>& c) {
+  return (obj->*method)(get<0>(p), get<0>(c), get<1>(c), get<2>(c));
 }
 template <typename R, typename Function, typename P1, typename C1, typename C2,
           typename C3>
 inline R DispatchToFunction(Function function,
-                            const Tuple1<P1>& p,
-                            const Tuple3<C1, C2, C3>& c) {
-  return (*function)(p.a, c.a, c.b, c.c);
+                            const Tuple<P1>& p,
+                            const Tuple<C1, C2, C3>& c) {
+  return (*function)(get<0>(p), get<0>(c), get<1>(c), get<2>(c));
 }
 
 // 1 - 4
 template <typename R, typename T, typename Method, typename P1, typename C1,
           typename C2, typename C3, typename C4>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple1<P1>& p,
-                          const Tuple4<C1, C2, C3, C4>& c) {
-  return (obj->*method)(p.a, c.a, c.b, c.c, c.d);
+                          const Tuple<P1>& p,
+                          const Tuple<C1, C2, C3, C4>& c) {
+  return (obj->*method)(get<0>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c));
 }
 template <typename R, typename Function, typename P1, typename C1, typename C2,
           typename C3, typename C4>
 inline R DispatchToFunction(Function function,
-                            const Tuple1<P1>& p,
-                            const Tuple4<C1, C2, C3, C4>& c) {
-  return (*function)(p.a, c.a, c.b, c.c, c.d);
+                            const Tuple<P1>& p,
+                            const Tuple<C1, C2, C3, C4>& c) {
+  return (*function)(get<0>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c));
 }
 
 // 1 - 5
 template <typename R, typename T, typename Method, typename P1, typename C1,
           typename C2, typename C3, typename C4, typename C5>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple1<P1>& p,
-                          const Tuple5<C1, C2, C3, C4, C5>& c) {
-  return (obj->*method)(p.a, c.a, c.b, c.c, c.d, c.e);
+                          const Tuple<P1>& p,
+                          const Tuple<C1, C2, C3, C4, C5>& c) {
+  return (obj->*method)(get<0>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
 }
 template <typename R, typename Function, typename P1, typename C1, typename C2,
           typename C3, typename C4, typename C5>
 inline R DispatchToFunction(Function function,
-                            const Tuple1<P1>& p,
-                            const Tuple5<C1, C2, C3, C4, C5>& c) {
-  return (*function)(p.a, c.a, c.b, c.c, c.d, c.e);
+                            const Tuple<P1>& p,
+                            const Tuple<C1, C2, C3, C4, C5>& c) {
+  return (*function)(get<0>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
 }
 
 // 1 - 6
 template <typename R, typename T, typename Method, typename P1, typename C1,
           typename C2, typename C3, typename C4, typename C5, typename C6>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple1<P1>& p,
-                          const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
-  return (obj->*method)(p.a, c.a, c.b, c.c, c.d, c.e, c.f);
+                          const Tuple<P1>& p,
+                          const Tuple<C1, C2, C3, C4, C5, C6>& c) {
+  return (obj->*method)(get<0>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
 }
 template <typename R, typename Function, typename P1, typename C1, typename C2,
           typename C3, typename C4, typename C5, typename C6>
 inline R DispatchToFunction(Function function,
-                            const Tuple1<P1>& p,
-                            const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
-  return (*function)(p.a, c.a, c.b, c.c, c.d, c.e, c.f);
+                            const Tuple<P1>& p,
+                            const Tuple<C1, C2, C3, C4, C5, C6>& c) {
+  return (*function)(get<0>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
 }
 
 // 2 - 0
 template <typename R, typename T, typename Method, typename P1, typename P2>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple2<P1, P2>& p,
-                          const Tuple0& c) {
-  return (obj->*method)(p.a, p.b);
+                          const Tuple<P1, P2>& p,
+                          const Tuple<>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p));
 }
 template <typename R, typename Function, typename P1, typename P2>
 inline R DispatchToFunction(Function function,
-                            const Tuple2<P1, P2>& p,
-                            const Tuple0& c) {
-  return (*function)(p.a, p.b);
+                            const Tuple<P1, P2>& p,
+                            const Tuple<>& c) {
+  return (*function)(get<0>(p), get<1>(p));
 }
 
 // 2 - 1
 template <typename R, typename T, typename Method, typename P1, typename P2,
           typename C1>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple2<P1, P2>& p,
-                          const Tuple1<C1>& c) {
-  return (obj->*method)(p.a, p.b, c.a);
+                          const Tuple<P1, P2>& p,
+                          const Tuple<C1>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<0>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename C1>
 inline R DispatchToFunction(Function function,
-                            const Tuple2<P1, P2>& p,
-                            const Tuple1<C1>& c) {
-  return (*function)(p.a, p.b, c.a);
+                            const Tuple<P1, P2>& p,
+                            const Tuple<C1>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<0>(c));
 }
 
 // 2 - 2
 template <typename R, typename T, typename Method, typename P1, typename P2,
           typename C1, typename C2>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple2<P1, P2>& p,
-                          const Tuple2<C1, C2>& c) {
-  return (obj->*method)(p.a, p.b, c.a, c.b);
+                          const Tuple<P1, P2>& p,
+                          const Tuple<C1, C2>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<0>(c), get<1>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename C1,
           typename C2>
 inline R DispatchToFunction(Function function,
-                            const Tuple2<P1, P2>& p,
-                            const Tuple2<C1, C2>& c) {
-  return (*function)(p.a, p.b, c.a, c.b);
+                            const Tuple<P1, P2>& p,
+                            const Tuple<C1, C2>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<0>(c), get<1>(c));
 }
 
 // 2 - 3
 template <typename R, typename T, typename Method, typename P1, typename P2,
           typename C1, typename C2, typename C3>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple2<P1, P2>& p,
-                          const Tuple3<C1, C2, C3>& c) {
-  return (obj->*method)(p.a, p.b, c.a, c.b, c.c);
+                          const Tuple<P1, P2>& p,
+                          const Tuple<C1, C2, C3>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename C1,
           typename C2, typename C3>
 inline R DispatchToFunction(Function function,
-                            const Tuple2<P1, P2>& p,
-                            const Tuple3<C1, C2, C3>& c) {
-  return (*function)(p.a, p.b, c.a, c.b, c.c);
+                            const Tuple<P1, P2>& p,
+                            const Tuple<C1, C2, C3>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c));
 }
 
 // 2 - 4
 template <typename R, typename T, typename Method, typename P1, typename P2,
           typename C1, typename C2, typename C3, typename C4>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple2<P1, P2>& p,
-                          const Tuple4<C1, C2, C3, C4>& c) {
-  return (obj->*method)(p.a, p.b, c.a, c.b, c.c, c.d);
+                          const Tuple<P1, P2>& p,
+                          const Tuple<C1, C2, C3, C4>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename C1,
           typename C2, typename C3, typename C4>
 inline R DispatchToFunction(Function function,
-                            const Tuple2<P1, P2>& p,
-                            const Tuple4<C1, C2, C3, C4>& c) {
-  return (*function)(p.a, p.b, c.a, c.b, c.c, c.d);
+                            const Tuple<P1, P2>& p,
+                            const Tuple<C1, C2, C3, C4>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c));
 }
 
 // 2 - 5
 template <typename R, typename T, typename Method, typename P1, typename P2,
           typename C1, typename C2, typename C3, typename C4, typename C5>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple2<P1, P2>& p,
-                          const Tuple5<C1, C2, C3, C4, C5>& c) {
-  return (obj->*method)(p.a, p.b, c.a, c.b, c.c, c.d, c.e);
+                          const Tuple<P1, P2>& p,
+                          const Tuple<C1, C2, C3, C4, C5>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename C1,
           typename C2, typename C3, typename C4, typename C5>
 inline R DispatchToFunction(Function function,
-                            const Tuple2<P1, P2>& p,
-                            const Tuple5<C1, C2, C3, C4, C5>& c) {
-  return (*function)(p.a, p.b, c.a, c.b, c.c, c.d, c.e);
+                            const Tuple<P1, P2>& p,
+                            const Tuple<C1, C2, C3, C4, C5>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
 }
 
 // 2 - 6
@@ -418,95 +418,95 @@ template <typename R, typename T, typename Method, typename P1, typename P2,
           typename C1, typename C2, typename C3, typename C4, typename C5,
           typename C6>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple2<P1, P2>& p,
-                          const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
-  return (obj->*method)(p.a, p.b, c.a, c.b, c.c, c.d, c.e, c.f);
+                          const Tuple<P1, P2>& p,
+                          const Tuple<C1, C2, C3, C4, C5, C6>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename C1,
           typename C2, typename C3, typename C4, typename C5, typename C6>
 inline R DispatchToFunction(Function function,
-                            const Tuple2<P1, P2>& p,
-                            const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
-  return (*function)(p.a, p.b, c.a, c.b, c.c, c.d, c.e, c.f);
+                            const Tuple<P1, P2>& p,
+                            const Tuple<C1, C2, C3, C4, C5, C6>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
 }
 
 // 3 - 0
 template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple3<P1, P2, P3>& p,
-                          const Tuple0& c) {
-  return (obj->*method)(p.a, p.b, p.c);
+                          const Tuple<P1, P2, P3>& p,
+                          const Tuple<>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3>
 inline R DispatchToFunction(Function function,
-                            const Tuple3<P1, P2, P3>& p,
-                            const Tuple0& c) {
-  return (*function)(p.a, p.b, p.c);
+                            const Tuple<P1, P2, P3>& p,
+                            const Tuple<>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p));
 }
 
 // 3 - 1
 template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename C1>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple3<P1, P2, P3>& p,
-                          const Tuple1<C1>& c) {
-  return (obj->*method)(p.a, p.b, p.c, c.a);
+                          const Tuple<P1, P2, P3>& p,
+                          const Tuple<C1>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<0>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename C1>
 inline R DispatchToFunction(Function function,
-                            const Tuple3<P1, P2, P3>& p,
-                            const Tuple1<C1>& c) {
-  return (*function)(p.a, p.b, p.c, c.a);
+                            const Tuple<P1, P2, P3>& p,
+                            const Tuple<C1>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<0>(c));
 }
 
 // 3 - 2
 template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename C1, typename C2>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple3<P1, P2, P3>& p,
-                          const Tuple2<C1, C2>& c) {
-  return (obj->*method)(p.a, p.b, p.c, c.a, c.b);
+                          const Tuple<P1, P2, P3>& p,
+                          const Tuple<C1, C2>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename C1, typename C2>
 inline R DispatchToFunction(Function function,
-                            const Tuple3<P1, P2, P3>& p,
-                            const Tuple2<C1, C2>& c) {
-  return (*function)(p.a, p.b, p.c, c.a, c.b);
+                            const Tuple<P1, P2, P3>& p,
+                            const Tuple<C1, C2>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c));
 }
 
 // 3 - 3
 template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename C1, typename C2, typename C3>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple3<P1, P2, P3>& p,
-                          const Tuple3<C1, C2, C3>& c) {
-  return (obj->*method)(p.a, p.b, p.c, c.a, c.b, c.c);
+                          const Tuple<P1, P2, P3>& p,
+                          const Tuple<C1, C2, C3>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename C1, typename C2, typename C3>
 inline R DispatchToFunction(Function function,
-                            const Tuple3<P1, P2, P3>& p,
-                            const Tuple3<C1, C2, C3>& c) {
-  return (*function)(p.a, p.b, p.c, c.a, c.b, c.c);
+                            const Tuple<P1, P2, P3>& p,
+                            const Tuple<C1, C2, C3>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c));
 }
 
 // 3 - 4
 template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename C1, typename C2, typename C3, typename C4>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple3<P1, P2, P3>& p,
-                          const Tuple4<C1, C2, C3, C4>& c) {
-  return (obj->*method)(p.a, p.b, p.c, c.a, c.b, c.c, c.d);
+                          const Tuple<P1, P2, P3>& p,
+                          const Tuple<C1, C2, C3, C4>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename C1, typename C2, typename C3, typename C4>
 inline R DispatchToFunction(Function function,
-                            const Tuple3<P1, P2, P3>& p,
-                            const Tuple4<C1, C2, C3, C4>& c) {
-  return (*function)(p.a, p.b, p.c, c.a, c.b, c.c, c.d);
+                            const Tuple<P1, P2, P3>& p,
+                            const Tuple<C1, C2, C3, C4>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c));
 }
 
 // 3 - 5
@@ -514,16 +514,16 @@ template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename C1, typename C2, typename C3, typename C4,
           typename C5>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple3<P1, P2, P3>& p,
-                          const Tuple5<C1, C2, C3, C4, C5>& c) {
-  return (obj->*method)(p.a, p.b, p.c, c.a, c.b, c.c, c.d, c.e);
+                          const Tuple<P1, P2, P3>& p,
+                          const Tuple<C1, C2, C3, C4, C5>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename C1, typename C2, typename C3, typename C4, typename C5>
 inline R DispatchToFunction(Function function,
-                            const Tuple3<P1, P2, P3>& p,
-                            const Tuple5<C1, C2, C3, C4, C5>& c) {
-  return (*function)(p.a, p.b, p.c, c.a, c.b, c.c, c.d, c.e);
+                            const Tuple<P1, P2, P3>& p,
+                            const Tuple<C1, C2, C3, C4, C5>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
 }
 
 // 3 - 6
@@ -531,81 +531,81 @@ template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename C1, typename C2, typename C3, typename C4,
           typename C5, typename C6>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple3<P1, P2, P3>& p,
-                          const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
-  return (obj->*method)(p.a, p.b, p.c, c.a, c.b, c.c, c.d, c.e, c.f);
+                          const Tuple<P1, P2, P3>& p,
+                          const Tuple<C1, C2, C3, C4, C5, C6>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename C1, typename C2, typename C3, typename C4, typename C5,
           typename C6>
 inline R DispatchToFunction(Function function,
-                            const Tuple3<P1, P2, P3>& p,
-                            const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
-  return (*function)(p.a, p.b, p.c, c.a, c.b, c.c, c.d, c.e, c.f);
+                            const Tuple<P1, P2, P3>& p,
+                            const Tuple<C1, C2, C3, C4, C5, C6>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
 }
 
 // 4 - 0
 template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename P4>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple4<P1, P2, P3, P4>& p,
-                          const Tuple0& c) {
-  return (obj->*method)(p.a, p.b, p.c, p.d);
+                          const Tuple<P1, P2, P3, P4>& p,
+                          const Tuple<>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename P4>
 inline R DispatchToFunction(Function function,
-                            const Tuple4<P1, P2, P3, P4>& p,
-                            const Tuple0& c) {
-  return (*function)(p.a, p.b, p.c, p.d);
+                            const Tuple<P1, P2, P3, P4>& p,
+                            const Tuple<>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p));
 }
 
 // 4 - 1
 template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename P4, typename C1>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple4<P1, P2, P3, P4>& p,
-                          const Tuple1<C1>& c) {
-  return (obj->*method)(p.a, p.b, p.c, p.d, c.a);
+                          const Tuple<P1, P2, P3, P4>& p,
+                          const Tuple<C1>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename P4, typename C1>
 inline R DispatchToFunction(Function function,
-                            const Tuple4<P1, P2, P3, P4>& p,
-                            const Tuple1<C1>& c) {
-  return (*function)(p.a, p.b, p.c, p.d, c.a);
+                            const Tuple<P1, P2, P3, P4>& p,
+                            const Tuple<C1>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c));
 }
 
 // 4 - 2
 template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename P4, typename C1, typename C2>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple4<P1, P2, P3, P4>& p,
-                          const Tuple2<C1, C2>& c) {
-  return (obj->*method)(p.a, p.b, p.c, p.d, c.a, c.b);
+                          const Tuple<P1, P2, P3, P4>& p,
+                          const Tuple<C1, C2>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename P4, typename C1, typename C2>
 inline R DispatchToFunction(Function function,
-                            const Tuple4<P1, P2, P3, P4>& p,
-                            const Tuple2<C1, C2>& c) {
-  return (*function)(p.a, p.b, p.c, p.d, c.a, c.b);
+                            const Tuple<P1, P2, P3, P4>& p,
+                            const Tuple<C1, C2>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c));
 }
 
 // 4 - 3
 template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename P4, typename C1, typename C2, typename C3>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple4<P1, P2, P3, P4>& p,
-                          const Tuple3<C1, C2, C3>& c) {
-  return (obj->*method)(p.a, p.b, p.c, p.d, c.a, c.b, c.c);
+                          const Tuple<P1, P2, P3, P4>& p,
+                          const Tuple<C1, C2, C3>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename P4, typename C1, typename C2, typename C3>
 inline R DispatchToFunction(Function function,
-                            const Tuple4<P1, P2, P3, P4>& p,
-                            const Tuple3<C1, C2, C3>& c) {
-  return (*function)(p.a, p.b, p.c, p.d, c.a, c.b, c.c);
+                            const Tuple<P1, P2, P3, P4>& p,
+                            const Tuple<C1, C2, C3>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c));
 }
 
 // 4 - 4
@@ -613,16 +613,16 @@ template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename P4, typename C1, typename C2, typename C3,
           typename C4>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple4<P1, P2, P3, P4>& p,
-                          const Tuple4<C1, C2, C3, C4>& c) {
-  return (obj->*method)(p.a, p.b, p.c, p.d, c.a, c.b, c.c, c.d);
+                          const Tuple<P1, P2, P3, P4>& p,
+                          const Tuple<C1, C2, C3, C4>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename P4, typename C1, typename C2, typename C3, typename C4>
 inline R DispatchToFunction(Function function,
-                            const Tuple4<P1, P2, P3, P4>& p,
-                            const Tuple4<C1, C2, C3, C4>& c) {
-  return (*function)(p.a, p.b, p.c, p.d, c.a, c.b, c.c, c.d);
+                            const Tuple<P1, P2, P3, P4>& p,
+                            const Tuple<C1, C2, C3, C4>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c));
 }
 
 // 4 - 5
@@ -630,17 +630,17 @@ template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename P4, typename C1, typename C2, typename C3,
           typename C4, typename C5>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple4<P1, P2, P3, P4>& p,
-                          const Tuple5<C1, C2, C3, C4, C5>& c) {
-  return (obj->*method)(p.a, p.b, p.c, p.d, c.a, c.b, c.c, c.d, c.e);
+                          const Tuple<P1, P2, P3, P4>& p,
+                          const Tuple<C1, C2, C3, C4, C5>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename P4, typename C1, typename C2, typename C3, typename C4,
           typename C5>
 inline R DispatchToFunction(Function function,
-                            const Tuple4<P1, P2, P3, P4>& p,
-                            const Tuple5<C1, C2, C3, C4, C5>& c) {
-  return (*function)(p.a, p.b, p.c, p.d, c.a, c.b, c.c, c.d, c.e);
+                            const Tuple<P1, P2, P3, P4>& p,
+                            const Tuple<C1, C2, C3, C4, C5>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
 }
 
 // 4 - 6
@@ -648,65 +648,65 @@ template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename P4, typename C1, typename C2, typename C3,
           typename C4, typename C5, typename C6>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple4<P1, P2, P3, P4>& p,
-                          const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
-  return (obj->*method)(p.a, p.b, p.c, p.d, c.a, c.b, c.c, c.d, c.e, c.f);
+                          const Tuple<P1, P2, P3, P4>& p,
+                          const Tuple<C1, C2, C3, C4, C5, C6>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename P4, typename C1, typename C2, typename C3, typename C4,
           typename C5, typename C6>
 inline R DispatchToFunction(Function function,
-                            const Tuple4<P1, P2, P3, P4>& p,
-                            const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
-  return (*function)(p.a, p.b, p.c, p.d, c.a, c.b, c.c, c.d, c.e, c.f);
+                            const Tuple<P1, P2, P3, P4>& p,
+                            const Tuple<C1, C2, C3, C4, C5, C6>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
 }
 
 // 5 - 0
 template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename P4, typename P5>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple5<P1, P2, P3, P4, P5>& p,
-                          const Tuple0& c) {
-  return (obj->*method)(p.a, p.b, p.c, p.d, p.e);
+                          const Tuple<P1, P2, P3, P4, P5>& p,
+                          const Tuple<>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename P4, typename P5>
 inline R DispatchToFunction(Function function,
-                            const Tuple5<P1, P2, P3, P4, P5>& p,
-                            const Tuple0& c) {
-  return (*function)(p.a, p.b, p.c, p.d, p.e);
+                            const Tuple<P1, P2, P3, P4, P5>& p,
+                            const Tuple<>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p));
 }
 
 // 5 - 1
 template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename C1>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple5<P1, P2, P3, P4, P5>& p,
-                          const Tuple1<C1>& c) {
-  return (obj->*method)(p.a, p.b, p.c, p.d, p.e, c.a);
+                          const Tuple<P1, P2, P3, P4, P5>& p,
+                          const Tuple<C1>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename P4, typename P5, typename C1>
 inline R DispatchToFunction(Function function,
-                            const Tuple5<P1, P2, P3, P4, P5>& p,
-                            const Tuple1<C1>& c) {
-  return (*function)(p.a, p.b, p.c, p.d, p.e, c.a);
+                            const Tuple<P1, P2, P3, P4, P5>& p,
+                            const Tuple<C1>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c));
 }
 
 // 5 - 2
 template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename C1, typename C2>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple5<P1, P2, P3, P4, P5>& p,
-                          const Tuple2<C1, C2>& c) {
-  return (obj->*method)(p.a, p.b, p.c, p.d, p.e, c.a, c.b);
+                          const Tuple<P1, P2, P3, P4, P5>& p,
+                          const Tuple<C1, C2>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename P4, typename P5, typename C1, typename C2>
 inline R DispatchToFunction(Function function,
-                            const Tuple5<P1, P2, P3, P4, P5>& p,
-                            const Tuple2<C1, C2>& c) {
-  return (*function)(p.a, p.b, p.c, p.d, p.e, c.a, c.b);
+                            const Tuple<P1, P2, P3, P4, P5>& p,
+                            const Tuple<C1, C2>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c));
 }
 
 // 5 - 3
@@ -714,16 +714,16 @@ template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename C1, typename C2,
           typename C3>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple5<P1, P2, P3, P4, P5>& p,
-                          const Tuple3<C1, C2, C3>& c) {
-  return (obj->*method)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c);
+                          const Tuple<P1, P2, P3, P4, P5>& p,
+                          const Tuple<C1, C2, C3>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename P4, typename P5, typename C1, typename C2, typename C3>
 inline R DispatchToFunction(Function function,
-                            const Tuple5<P1, P2, P3, P4, P5>& p,
-                            const Tuple3<C1, C2, C3>& c) {
-  return (*function)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c);
+                            const Tuple<P1, P2, P3, P4, P5>& p,
+                            const Tuple<C1, C2, C3>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c));
 }
 
 // 5 - 4
@@ -731,17 +731,17 @@ template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename C1, typename C2,
           typename C3, typename C4>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple5<P1, P2, P3, P4, P5>& p,
-                          const Tuple4<C1, C2, C3, C4>& c) {
-  return (obj->*method)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c, c.d);
+                          const Tuple<P1, P2, P3, P4, P5>& p,
+                          const Tuple<C1, C2, C3, C4>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename P4, typename P5, typename C1, typename C2, typename C3,
           typename C4>
 inline R DispatchToFunction(Function function,
-                            const Tuple5<P1, P2, P3, P4, P5>& p,
-                            const Tuple4<C1, C2, C3, C4>& c) {
-  return (*function)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c, c.d);
+                            const Tuple<P1, P2, P3, P4, P5>& p,
+                            const Tuple<C1, C2, C3, C4>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c));
 }
 
 // 5 - 5
@@ -749,17 +749,17 @@ template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename C1, typename C2,
           typename C3, typename C4, typename C5>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple5<P1, P2, P3, P4, P5>& p,
-                          const Tuple5<C1, C2, C3, C4, C5>& c) {
-  return (obj->*method)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c, c.d, c.e);
+                          const Tuple<P1, P2, P3, P4, P5>& p,
+                          const Tuple<C1, C2, C3, C4, C5>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename P4, typename P5, typename C1, typename C2, typename C3,
           typename C4, typename C5>
 inline R DispatchToFunction(Function function,
-                            const Tuple5<P1, P2, P3, P4, P5>& p,
-                            const Tuple5<C1, C2, C3, C4, C5>& c) {
-  return (*function)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c, c.d, c.e);
+                            const Tuple<P1, P2, P3, P4, P5>& p,
+                            const Tuple<C1, C2, C3, C4, C5>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
 }
 
 // 5 - 6
@@ -767,49 +767,49 @@ template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename C1, typename C2,
           typename C3, typename C4, typename C5, typename C6>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple5<P1, P2, P3, P4, P5>& p,
-                          const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
-  return (obj->*method)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c, c.d, c.e, c.f);
+                          const Tuple<P1, P2, P3, P4, P5>& p,
+                          const Tuple<C1, C2, C3, C4, C5, C6>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename P4, typename P5, typename C1, typename C2, typename C3,
           typename C4, typename C5, typename C6>
 inline R DispatchToFunction(Function function,
-                            const Tuple5<P1, P2, P3, P4, P5>& p,
-                            const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
-  return (*function)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c, c.d, c.e, c.f);
+                            const Tuple<P1, P2, P3, P4, P5>& p,
+                            const Tuple<C1, C2, C3, C4, C5, C6>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
 }
 
 // 6 - 0
 template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple6<P1, P2, P3, P4, P5, P6>& p,
-                          const Tuple0& c) {
-  return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f);
+                          const Tuple<P1, P2, P3, P4, P5, P6>& p,
+                          const Tuple<>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename P4, typename P5, typename P6>
 inline R DispatchToFunction(Function function,
-                            const Tuple6<P1, P2, P3, P4, P5, P6>& p,
-                            const Tuple0& c) {
-  return (*function)(p.a, p.b, p.c, p.d, p.e, p.f);
+                            const Tuple<P1, P2, P3, P4, P5, P6>& p,
+                            const Tuple<>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p));
 }
 
 // 6 - 1
 template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename C1>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple6<P1, P2, P3, P4, P5, P6>& p,
-                          const Tuple1<C1>& c) {
-  return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f, c.a);
+                          const Tuple<P1, P2, P3, P4, P5, P6>& p,
+                          const Tuple<C1>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename P4, typename P5, typename P6, typename C1>
 inline R DispatchToFunction(Function function,
-                            const Tuple6<P1, P2, P3, P4, P5, P6>& p,
-                            const Tuple1<C1>& c) {
-  return (*function)(p.a, p.b, p.c, p.d, p.e, p.f, c.a);
+                            const Tuple<P1, P2, P3, P4, P5, P6>& p,
+                            const Tuple<C1>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c));
 }
 
 // 6 - 2
@@ -817,16 +817,16 @@ template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename C1,
           typename C2>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple6<P1, P2, P3, P4, P5, P6>& p,
-                          const Tuple2<C1, C2>& c) {
-  return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b);
+                          const Tuple<P1, P2, P3, P4, P5, P6>& p,
+                          const Tuple<C1, C2>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename P4, typename P5, typename P6, typename C1, typename C2>
 inline R DispatchToFunction(Function function,
-                            const Tuple6<P1, P2, P3, P4, P5, P6>& p,
-                            const Tuple2<C1, C2>& c) {
-  return (*function)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b);
+                            const Tuple<P1, P2, P3, P4, P5, P6>& p,
+                            const Tuple<C1, C2>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c));
 }
 
 // 6 - 3
@@ -834,17 +834,17 @@ template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename C1,
           typename C2, typename C3>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple6<P1, P2, P3, P4, P5, P6>& p,
-                          const Tuple3<C1, C2, C3>& c) {
-  return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c);
+                          const Tuple<P1, P2, P3, P4, P5, P6>& p,
+                          const Tuple<C1, C2, C3>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename P4, typename P5, typename P6, typename C1, typename C2,
           typename C3>
 inline R DispatchToFunction(Function function,
-                            const Tuple6<P1, P2, P3, P4, P5, P6>& p,
-                            const Tuple3<C1, C2, C3>& c) {
-  return (*function)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c);
+                            const Tuple<P1, P2, P3, P4, P5, P6>& p,
+                            const Tuple<C1, C2, C3>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c));
 }
 
 // 6 - 4
@@ -852,17 +852,17 @@ template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename C1,
           typename C2, typename C3, typename C4>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple6<P1, P2, P3, P4, P5, P6>& p,
-                          const Tuple4<C1, C2, C3, C4>& c) {
-  return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c, c.d);
+                          const Tuple<P1, P2, P3, P4, P5, P6>& p,
+                          const Tuple<C1, C2, C3, C4>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename P4, typename P5, typename P6, typename C1, typename C2,
           typename C3, typename C4>
 inline R DispatchToFunction(Function function,
-                            const Tuple6<P1, P2, P3, P4, P5, P6>& p,
-                            const Tuple4<C1, C2, C3, C4>& c) {
-  return (*function)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c, c.d);
+                            const Tuple<P1, P2, P3, P4, P5, P6>& p,
+                            const Tuple<C1, C2, C3, C4>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c));
 }
 
 // 6 - 5
@@ -870,17 +870,17 @@ template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename C1,
           typename C2, typename C3, typename C4, typename C5>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple6<P1, P2, P3, P4, P5, P6>& p,
-                          const Tuple5<C1, C2, C3, C4, C5>& c) {
-  return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c, c.d, c.e);
+                          const Tuple<P1, P2, P3, P4, P5, P6>& p,
+                          const Tuple<C1, C2, C3, C4, C5>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename P4, typename P5, typename P6, typename C1, typename C2,
           typename C3, typename C4, typename C5>
 inline R DispatchToFunction(Function function,
-                            const Tuple6<P1, P2, P3, P4, P5, P6>& p,
-                            const Tuple5<C1, C2, C3, C4, C5>& c) {
-  return (*function)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c, c.d, c.e);
+                            const Tuple<P1, P2, P3, P4, P5, P6>& p,
+                            const Tuple<C1, C2, C3, C4, C5>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c));
 }
 
 // 6 - 6
@@ -888,17 +888,17 @@ template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename C1,
           typename C2, typename C3, typename C4, typename C5, typename C6>
 inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple6<P1, P2, P3, P4, P5, P6>& p,
-                          const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
-  return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c, c.d, c.e, c.f);
+                          const Tuple<P1, P2, P3, P4, P5, P6>& p,
+                          const Tuple<C1, C2, C3, C4, C5, C6>& c) {
+  return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
 }
 template <typename R, typename Function, typename P1, typename P2, typename P3,
           typename P4, typename P5, typename P6, typename C1, typename C2,
           typename C3, typename C4, typename C5, typename C6>
 inline R DispatchToFunction(Function function,
-                            const Tuple6<P1, P2, P3, P4, P5, P6>& p,
-                            const Tuple6<C1, C2, C3, C4, C5, C6>& c) {
-  return (*function)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c, c.d, c.e, c.f);
+                            const Tuple<P1, P2, P3, P4, P5, P6>& p,
+                            const Tuple<C1, C2, C3, C4, C5, C6>& c) {
+  return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c));
 }
 
 // Interface that is exposed to the consumer, that does the actual calling
@@ -984,7 +984,7 @@ struct MutantFunctor {
   }
 
   inline R operator()() {
-    return impl_->RunWithParams(Tuple0());
+    return impl_->RunWithParams(Tuple<>());
   }
 
   template <typename Arg1>
@@ -1017,198 +1017,198 @@ struct MutantFunctor {
 
 // 0 - 0
 template <typename R, typename T, typename U>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T* obj, R (U::*method)()) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new Mutant<R, T, R (U::*)(),
-                 Tuple0, Tuple0>
+                 Tuple<>, Tuple<>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 
 template <typename R>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(R (*function)()) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantFunction<R, R (*)(),
-                         Tuple0, Tuple0>
+                         Tuple<>, Tuple<>>
           (function, MakeTuple());
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T** obj, R (U::*method)()) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(),
-                               Tuple0, Tuple0>
+                               Tuple<>, Tuple<>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
 #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T* obj, R (__stdcall U::*method)()) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new Mutant<R, T, R (__stdcall U::*)(),
-                 Tuple0, Tuple0>
+                 Tuple<>, Tuple<>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 
 template <typename R>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(R (__stdcall *function)()) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantFunction<R, R (__stdcall *)(),
-                         Tuple0, Tuple0>
+                         Tuple<>, Tuple<>>
           (function, MakeTuple());
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T** obj, R (__stdcall U::*method)()) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(),
-                               Tuple0, Tuple0>
+                               Tuple<>, Tuple<>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 0 - 1
 template <typename R, typename T, typename U, typename A1>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T* obj, R (U::*method)(A1)) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new Mutant<R, T, R (U::*)(A1),
-                 Tuple0, Tuple1<A1> >
+                 Tuple<>, Tuple<A1>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 
 template <typename R, typename A1>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(R (*function)(A1)) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantFunction<R, R (*)(A1),
-                         Tuple0, Tuple1<A1> >
+                         Tuple<>, Tuple<A1>>
           (function, MakeTuple());
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename A1>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T** obj, R (U::*method)(A1)) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(A1),
-                               Tuple0, Tuple1<A1> >
+                               Tuple<>, Tuple<A1>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
 #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename A1>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(A1)) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new Mutant<R, T, R (__stdcall U::*)(A1),
-                 Tuple0, Tuple1<A1> >
+                 Tuple<>, Tuple<A1>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 
 template <typename R, typename A1>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(R (__stdcall *function)(A1)) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantFunction<R, R (__stdcall *)(A1),
-                         Tuple0, Tuple1<A1> >
+                         Tuple<>, Tuple<A1>>
           (function, MakeTuple());
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename A1>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(A1)) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1),
-                               Tuple0, Tuple1<A1> >
+                               Tuple<>, Tuple<A1>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 0 - 2
 template <typename R, typename T, typename U, typename A1, typename A2>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T* obj, R (U::*method)(A1, A2)) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new Mutant<R, T, R (U::*)(A1, A2),
-                 Tuple0, Tuple2<A1, A2> >
+                 Tuple<>, Tuple<A1, A2>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 
 template <typename R, typename A1, typename A2>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(R (*function)(A1, A2)) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantFunction<R, R (*)(A1, A2),
-                         Tuple0, Tuple2<A1, A2> >
+                         Tuple<>, Tuple<A1, A2>>
           (function, MakeTuple());
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename A1, typename A2>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T** obj, R (U::*method)(A1, A2)) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(A1, A2),
-                               Tuple0, Tuple2<A1, A2> >
+                               Tuple<>, Tuple<A1, A2>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
 #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename A1, typename A2>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2)) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new Mutant<R, T, R (__stdcall U::*)(A1, A2),
-                 Tuple0, Tuple2<A1, A2> >
+                 Tuple<>, Tuple<A1, A2>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 
 template <typename R, typename A1, typename A2>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(R (__stdcall *function)(A1, A2)) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantFunction<R, R (__stdcall *)(A1, A2),
-                         Tuple0, Tuple2<A1, A2> >
+                         Tuple<>, Tuple<A1, A2>>
           (function, MakeTuple());
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename A1, typename A2>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2)) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1, A2),
-                               Tuple0, Tuple2<A1, A2> >
+                               Tuple<>, Tuple<A1, A2>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -1216,69 +1216,69 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2)) {
 // 0 - 3
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T* obj, R (U::*method)(A1, A2, A3)) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new Mutant<R, T, R (U::*)(A1, A2, A3),
-                 Tuple0, Tuple3<A1, A2, A3> >
+                 Tuple<>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 
 template <typename R, typename A1, typename A2, typename A3>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(R (*function)(A1, A2, A3)) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantFunction<R, R (*)(A1, A2, A3),
-                         Tuple0, Tuple3<A1, A2, A3> >
+                         Tuple<>, Tuple<A1, A2, A3>>
           (function, MakeTuple());
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T** obj, R (U::*method)(A1, A2, A3)) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(A1, A2, A3),
-                               Tuple0, Tuple3<A1, A2, A3> >
+                               Tuple<>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
 #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3)) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new Mutant<R, T, R (__stdcall U::*)(A1, A2, A3),
-                 Tuple0, Tuple3<A1, A2, A3> >
+                 Tuple<>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 
 template <typename R, typename A1, typename A2, typename A3>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(R (__stdcall *function)(A1, A2, A3)) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantFunction<R, R (__stdcall *)(A1, A2, A3),
-                         Tuple0, Tuple3<A1, A2, A3> >
+                         Tuple<>, Tuple<A1, A2, A3>>
           (function, MakeTuple());
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3)) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1, A2, A3),
-                               Tuple0, Tuple3<A1, A2, A3> >
+                               Tuple<>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -1286,69 +1286,69 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3)) {
 // 0 - 4
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3, typename A4>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T* obj, R (U::*method)(A1, A2, A3, A4)) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new Mutant<R, T, R (U::*)(A1, A2, A3, A4),
-                 Tuple0, Tuple4<A1, A2, A3, A4> >
+                 Tuple<>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 
 template <typename R, typename A1, typename A2, typename A3, typename A4>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(R (*function)(A1, A2, A3, A4)) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantFunction<R, R (*)(A1, A2, A3, A4),
-                         Tuple0, Tuple4<A1, A2, A3, A4> >
+                         Tuple<>, Tuple<A1, A2, A3, A4>>
           (function, MakeTuple());
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3, typename A4>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T** obj, R (U::*method)(A1, A2, A3, A4)) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(A1, A2, A3, A4),
-                               Tuple0, Tuple4<A1, A2, A3, A4> >
+                               Tuple<>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
 #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3, typename A4>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3, A4)) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new Mutant<R, T, R (__stdcall U::*)(A1, A2, A3, A4),
-                 Tuple0, Tuple4<A1, A2, A3, A4> >
+                 Tuple<>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 
 template <typename R, typename A1, typename A2, typename A3, typename A4>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(R (__stdcall *function)(A1, A2, A3, A4)) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantFunction<R, R (__stdcall *)(A1, A2, A3, A4),
-                         Tuple0, Tuple4<A1, A2, A3, A4> >
+                         Tuple<>, Tuple<A1, A2, A3, A4>>
           (function, MakeTuple());
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3, typename A4>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4)) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1, A2, A3, A4),
-                               Tuple0, Tuple4<A1, A2, A3, A4> >
+                               Tuple<>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -1356,71 +1356,71 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4)) {
 // 0 - 5
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3, typename A4, typename A5>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T* obj, R (U::*method)(A1, A2, A3, A4, A5)) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new Mutant<R, T, R (U::*)(A1, A2, A3, A4, A5),
-                 Tuple0, Tuple5<A1, A2, A3, A4, A5> >
+                 Tuple<>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 
 template <typename R, typename A1, typename A2, typename A3, typename A4,
           typename A5>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(R (*function)(A1, A2, A3, A4, A5)) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantFunction<R, R (*)(A1, A2, A3, A4, A5),
-                         Tuple0, Tuple5<A1, A2, A3, A4, A5> >
+                         Tuple<>, Tuple<A1, A2, A3, A4, A5>>
           (function, MakeTuple());
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3, typename A4, typename A5>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T** obj, R (U::*method)(A1, A2, A3, A4, A5)) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(A1, A2, A3, A4, A5),
-                               Tuple0, Tuple5<A1, A2, A3, A4, A5> >
+                               Tuple<>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
 #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3, typename A4, typename A5>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5)) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new Mutant<R, T, R (__stdcall U::*)(A1, A2, A3, A4, A5),
-                 Tuple0, Tuple5<A1, A2, A3, A4, A5> >
+                 Tuple<>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 
 template <typename R, typename A1, typename A2, typename A3, typename A4,
           typename A5>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(R (__stdcall *function)(A1, A2, A3, A4, A5)) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantFunction<R, R (__stdcall *)(A1, A2, A3, A4, A5),
-                         Tuple0, Tuple5<A1, A2, A3, A4, A5> >
+                         Tuple<>, Tuple<A1, A2, A3, A4, A5>>
           (function, MakeTuple());
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3, typename A4, typename A5>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5)) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1, A2, A3, A4, A5),
-                               Tuple0, Tuple5<A1, A2, A3, A4, A5> >
+                               Tuple<>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -1428,137 +1428,137 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5)) {
 // 0 - 6
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3, typename A4, typename A5, typename A6>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T* obj, R (U::*method)(A1, A2, A3, A4, A5, A6)) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new Mutant<R, T, R (U::*)(A1, A2, A3, A4, A5, A6),
-                 Tuple0, Tuple6<A1, A2, A3, A4, A5, A6> >
+                 Tuple<>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 
 template <typename R, typename A1, typename A2, typename A3, typename A4,
           typename A5, typename A6>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(R (*function)(A1, A2, A3, A4, A5, A6)) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantFunction<R, R (*)(A1, A2, A3, A4, A5, A6),
-                         Tuple0, Tuple6<A1, A2, A3, A4, A5, A6> >
+                         Tuple<>, Tuple<A1, A2, A3, A4, A5, A6>>
           (function, MakeTuple());
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3, typename A4, typename A5, typename A6>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T** obj, R (U::*method)(A1, A2, A3, A4, A5, A6)) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(A1, A2, A3, A4, A5, A6),
-                               Tuple0, Tuple6<A1, A2, A3, A4, A5, A6> >
+                               Tuple<>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
 #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3, typename A4, typename A5, typename A6>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5, A6)) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new Mutant<R, T, R (__stdcall U::*)(A1, A2, A3, A4, A5, A6),
-                 Tuple0, Tuple6<A1, A2, A3, A4, A5, A6> >
+                 Tuple<>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 
 template <typename R, typename A1, typename A2, typename A3, typename A4,
           typename A5, typename A6>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(R (__stdcall *function)(A1, A2, A3, A4, A5, A6)) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantFunction<R, R (__stdcall *)(A1, A2, A3, A4, A5, A6),
-                         Tuple0, Tuple6<A1, A2, A3, A4, A5, A6> >
+                         Tuple<>, Tuple<A1, A2, A3, A4, A5, A6>>
           (function, MakeTuple());
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3, typename A4, typename A5, typename A6>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5, A6)) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1, A2, A3, A4, A5, A6),
-                               Tuple0, Tuple6<A1, A2, A3, A4, A5, A6> >
+                               Tuple<>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 1 - 0
 template <typename R, typename T, typename U, typename P1, typename X1>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T* obj, R (U::*method)(X1), const P1& p1) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new Mutant<R, T, R (U::*)(X1),
-                 Tuple1<P1>, Tuple0>
+                 Tuple<P1>, Tuple<>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 
 template <typename R, typename P1, typename X1>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(R (*function)(X1), const P1& p1) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantFunction<R, R (*)(X1),
-                         Tuple1<P1>, Tuple0>
+                         Tuple<P1>, Tuple<>>
           (function, MakeTuple(p1));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename X1>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T** obj, R (U::*method)(X1), const P1& p1) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1),
-                               Tuple1<P1>, Tuple0>
+                               Tuple<P1>, Tuple<>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
 #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename X1>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1), const P1& p1) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1),
-                 Tuple1<P1>, Tuple0>
+                 Tuple<P1>, Tuple<>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 
 template <typename R, typename P1, typename X1>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(R (__stdcall *function)(X1), const P1& p1) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantFunction<R, R (__stdcall *)(X1),
-                         Tuple1<P1>, Tuple0>
+                         Tuple<P1>, Tuple<>>
           (function, MakeTuple(p1));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename X1>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1), const P1& p1) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1),
-                               Tuple1<P1>, Tuple0>
+                               Tuple<P1>, Tuple<>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -1566,69 +1566,69 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1), const P1& p1) {
 // 1 - 1
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename X1>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T* obj, R (U::*method)(X1, A1), const P1& p1) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new Mutant<R, T, R (U::*)(X1, A1),
-                 Tuple1<P1>, Tuple1<A1> >
+                 Tuple<P1>, Tuple<A1>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 
 template <typename R, typename P1, typename A1, typename X1>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(R (*function)(X1, A1), const P1& p1) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantFunction<R, R (*)(X1, A1),
-                         Tuple1<P1>, Tuple1<A1> >
+                         Tuple<P1>, Tuple<A1>>
           (function, MakeTuple(p1));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename X1>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T** obj, R (U::*method)(X1, A1), const P1& p1) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, A1),
-                               Tuple1<P1>, Tuple1<A1> >
+                               Tuple<P1>, Tuple<A1>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
 #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename X1>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1), const P1& p1) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, A1),
-                 Tuple1<P1>, Tuple1<A1> >
+                 Tuple<P1>, Tuple<A1>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 
 template <typename R, typename P1, typename A1, typename X1>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(R (__stdcall *function)(X1, A1), const P1& p1) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, A1),
-                         Tuple1<P1>, Tuple1<A1> >
+                         Tuple<P1>, Tuple<A1>>
           (function, MakeTuple(p1));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename X1>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1), const P1& p1) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1),
-                               Tuple1<P1>, Tuple1<A1> >
+                               Tuple<P1>, Tuple<A1>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -1636,69 +1636,69 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1), const P1& p1) {
 // 1 - 2
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename X1>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T* obj, R (U::*method)(X1, A1, A2), const P1& p1) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new Mutant<R, T, R (U::*)(X1, A1, A2),
-                 Tuple1<P1>, Tuple2<A1, A2> >
+                 Tuple<P1>, Tuple<A1, A2>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 
 template <typename R, typename P1, typename A1, typename A2, typename X1>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(R (*function)(X1, A1, A2), const P1& p1) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantFunction<R, R (*)(X1, A1, A2),
-                         Tuple1<P1>, Tuple2<A1, A2> >
+                         Tuple<P1>, Tuple<A1, A2>>
           (function, MakeTuple(p1));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename X1>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T** obj, R (U::*method)(X1, A1, A2), const P1& p1) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, A1, A2),
-                               Tuple1<P1>, Tuple2<A1, A2> >
+                               Tuple<P1>, Tuple<A1, A2>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
 #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename X1>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2), const P1& p1) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, A1, A2),
-                 Tuple1<P1>, Tuple2<A1, A2> >
+                 Tuple<P1>, Tuple<A1, A2>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 
 template <typename R, typename P1, typename A1, typename A2, typename X1>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(R (__stdcall *function)(X1, A1, A2), const P1& p1) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, A1, A2),
-                         Tuple1<P1>, Tuple2<A1, A2> >
+                         Tuple<P1>, Tuple<A1, A2>>
           (function, MakeTuple(p1));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename X1>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2), const P1& p1) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1, A2),
-                               Tuple1<P1>, Tuple2<A1, A2> >
+                               Tuple<P1>, Tuple<A1, A2>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -1706,71 +1706,71 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2), const P1& p1) {
 // 1 - 3
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename A3, typename X1>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T* obj, R (U::*method)(X1, A1, A2, A3), const P1& p1) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new Mutant<R, T, R (U::*)(X1, A1, A2, A3),
-                 Tuple1<P1>, Tuple3<A1, A2, A3> >
+                 Tuple<P1>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 
 template <typename R, typename P1, typename A1, typename A2, typename A3,
           typename X1>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(R (*function)(X1, A1, A2, A3), const P1& p1) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantFunction<R, R (*)(X1, A1, A2, A3),
-                         Tuple1<P1>, Tuple3<A1, A2, A3> >
+                         Tuple<P1>, Tuple<A1, A2, A3>>
           (function, MakeTuple(p1));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename A3, typename X1>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3), const P1& p1) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, A1, A2, A3),
-                               Tuple1<P1>, Tuple3<A1, A2, A3> >
+                               Tuple<P1>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
 #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename A3, typename X1>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2, A3), const P1& p1) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, A1, A2, A3),
-                 Tuple1<P1>, Tuple3<A1, A2, A3> >
+                 Tuple<P1>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 
 template <typename R, typename P1, typename A1, typename A2, typename A3,
           typename X1>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(R (__stdcall *function)(X1, A1, A2, A3), const P1& p1) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, A1, A2, A3),
-                         Tuple1<P1>, Tuple3<A1, A2, A3> >
+                         Tuple<P1>, Tuple<A1, A2, A3>>
           (function, MakeTuple(p1));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename A3, typename X1>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3), const P1& p1) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1, A2, A3),
-                               Tuple1<P1>, Tuple3<A1, A2, A3> >
+                               Tuple<P1>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -1778,73 +1778,73 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3), const P1& p1) {
 // 1 - 4
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename A3, typename A4, typename X1>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T* obj, R (U::*method)(X1, A1, A2, A3, A4), const P1& p1) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new Mutant<R, T, R (U::*)(X1, A1, A2, A3, A4),
-                 Tuple1<P1>, Tuple4<A1, A2, A3, A4> >
+                 Tuple<P1>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 
 template <typename R, typename P1, typename A1, typename A2, typename A3,
           typename A4, typename X1>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(R (*function)(X1, A1, A2, A3, A4), const P1& p1) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantFunction<R, R (*)(X1, A1, A2, A3, A4),
-                         Tuple1<P1>, Tuple4<A1, A2, A3, A4> >
+                         Tuple<P1>, Tuple<A1, A2, A3, A4>>
           (function, MakeTuple(p1));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename A3, typename A4, typename X1>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3, A4), const P1& p1) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, A1, A2, A3, A4),
-                               Tuple1<P1>, Tuple4<A1, A2, A3, A4> >
+                               Tuple<P1>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
 #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename A3, typename A4, typename X1>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4),
     const P1& p1) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4),
-                 Tuple1<P1>, Tuple4<A1, A2, A3, A4> >
+                 Tuple<P1>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 
 template <typename R, typename P1, typename A1, typename A2, typename A3,
           typename A4, typename X1>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(R (__stdcall *function)(X1, A1, A2, A3, A4), const P1& p1) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, A1, A2, A3, A4),
-                         Tuple1<P1>, Tuple4<A1, A2, A3, A4> >
+                         Tuple<P1>, Tuple<A1, A2, A3, A4>>
           (function, MakeTuple(p1));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename A3, typename A4, typename X1>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4),
     const P1& p1) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4),
-                               Tuple1<P1>, Tuple4<A1, A2, A3, A4> >
+                               Tuple<P1>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -1852,73 +1852,73 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4),
 // 1 - 5
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename A3, typename A4, typename A5, typename X1>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T* obj, R (U::*method)(X1, A1, A2, A3, A4, A5), const P1& p1) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new Mutant<R, T, R (U::*)(X1, A1, A2, A3, A4, A5),
-                 Tuple1<P1>, Tuple5<A1, A2, A3, A4, A5> >
+                 Tuple<P1>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 
 template <typename R, typename P1, typename A1, typename A2, typename A3,
           typename A4, typename A5, typename X1>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(R (*function)(X1, A1, A2, A3, A4, A5), const P1& p1) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantFunction<R, R (*)(X1, A1, A2, A3, A4, A5),
-                         Tuple1<P1>, Tuple5<A1, A2, A3, A4, A5> >
+                         Tuple<P1>, Tuple<A1, A2, A3, A4, A5>>
           (function, MakeTuple(p1));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename A3, typename A4, typename A5, typename X1>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3, A4, A5), const P1& p1) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, A1, A2, A3, A4, A5),
-                               Tuple1<P1>, Tuple5<A1, A2, A3, A4, A5> >
+                               Tuple<P1>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
 #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename A3, typename A4, typename A5, typename X1>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5),
     const P1& p1) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4, A5),
-                 Tuple1<P1>, Tuple5<A1, A2, A3, A4, A5> >
+                 Tuple<P1>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 
 template <typename R, typename P1, typename A1, typename A2, typename A3,
           typename A4, typename A5, typename X1>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(R (__stdcall *function)(X1, A1, A2, A3, A4, A5), const P1& p1) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, A1, A2, A3, A4, A5),
-                         Tuple1<P1>, Tuple5<A1, A2, A3, A4, A5> >
+                         Tuple<P1>, Tuple<A1, A2, A3, A4, A5>>
           (function, MakeTuple(p1));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename A3, typename A4, typename A5, typename X1>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5),
     const P1& p1) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4, A5),
-                               Tuple1<P1>, Tuple5<A1, A2, A3, A4, A5> >
+                               Tuple<P1>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -1927,39 +1927,39 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5),
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename A3, typename A4, typename A5, typename A6,
           typename X1>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T* obj, R (U::*method)(X1, A1, A2, A3, A4, A5, A6),
     const P1& p1) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new Mutant<R, T, R (U::*)(X1, A1, A2, A3, A4, A5, A6),
-                 Tuple1<P1>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                 Tuple<P1>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 
 template <typename R, typename P1, typename A1, typename A2, typename A3,
           typename A4, typename A5, typename A6, typename X1>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(R (*function)(X1, A1, A2, A3, A4, A5, A6), const P1& p1) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantFunction<R, R (*)(X1, A1, A2, A3, A4, A5, A6),
-                         Tuple1<P1>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                         Tuple<P1>, Tuple<A1, A2, A3, A4, A5, A6>>
           (function, MakeTuple(p1));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename A3, typename A4, typename A5, typename A6,
           typename X1>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3, A4, A5, A6),
     const P1& p1) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, A1, A2, A3, A4, A5, A6),
-                               Tuple1<P1>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                               Tuple<P1>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -1967,39 +1967,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3, A4, A5, A6),
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename A3, typename A4, typename A5, typename A6,
           typename X1>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5, A6),
     const P1& p1) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4, A5, A6),
-                 Tuple1<P1>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                 Tuple<P1>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 
 template <typename R, typename P1, typename A1, typename A2, typename A3,
           typename A4, typename A5, typename A6, typename X1>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(R (__stdcall *function)(X1, A1, A2, A3, A4, A5, A6),
     const P1& p1) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, A1, A2, A3, A4, A5, A6),
-                         Tuple1<P1>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                         Tuple<P1>, Tuple<A1, A2, A3, A4, A5, A6>>
           (function, MakeTuple(p1));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename A3, typename A4, typename A5, typename A6,
           typename X1>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5, A6),
     const P1& p1) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4, A5, A6),
-                               Tuple1<P1>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                               Tuple<P1>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -2007,71 +2007,71 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5, A6),
 // 2 - 0
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename X1, typename X2>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2), const P1& p1, const P2& p2) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new Mutant<R, T, R (U::*)(X1, X2),
-                 Tuple2<P1, P2>, Tuple0>
+                 Tuple<P1, P2>, Tuple<>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename X1, typename X2>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(R (*function)(X1, X2), const P1& p1, const P2& p2) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantFunction<R, R (*)(X1, X2),
-                         Tuple2<P1, P2>, Tuple0>
+                         Tuple<P1, P2>, Tuple<>>
           (function, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename X1, typename X2>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2), const P1& p1, const P2& p2) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2),
-                               Tuple2<P1, P2>, Tuple0>
+                               Tuple<P1, P2>, Tuple<>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
 #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename X1, typename X2>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2), const P1& p1,
     const P2& p2) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2),
-                 Tuple2<P1, P2>, Tuple0>
+                 Tuple<P1, P2>, Tuple<>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename X1, typename X2>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(R (__stdcall *function)(X1, X2), const P1& p1, const P2& p2) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2),
-                         Tuple2<P1, P2>, Tuple0>
+                         Tuple<P1, P2>, Tuple<>>
           (function, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename X1, typename X2>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2), const P1& p1,
     const P2& p2) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2),
-                               Tuple2<P1, P2>, Tuple0>
+                               Tuple<P1, P2>, Tuple<>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -2079,74 +2079,74 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2), const P1& p1,
 // 2 - 1
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename X1, typename X2>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, A1), const P1& p1, const P2& p2) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, A1),
-                 Tuple2<P1, P2>, Tuple1<A1> >
+                 Tuple<P1, P2>, Tuple<A1>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename A1, typename X1,
           typename X2>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(R (*function)(X1, X2, A1), const P1& p1, const P2& p2) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantFunction<R, R (*)(X1, X2, A1),
-                         Tuple2<P1, P2>, Tuple1<A1> >
+                         Tuple<P1, P2>, Tuple<A1>>
           (function, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename X1, typename X2>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, A1), const P1& p1, const P2& p2) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, A1),
-                               Tuple2<P1, P2>, Tuple1<A1> >
+                               Tuple<P1, P2>, Tuple<A1>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
 #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename X1, typename X2>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1), const P1& p1,
     const P2& p2) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1),
-                 Tuple2<P1, P2>, Tuple1<A1> >
+                 Tuple<P1, P2>, Tuple<A1>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename A1, typename X1,
           typename X2>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(R (__stdcall *function)(X1, X2, A1), const P1& p1,
     const P2& p2) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, A1),
-                         Tuple2<P1, P2>, Tuple1<A1> >
+                         Tuple<P1, P2>, Tuple<A1>>
           (function, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename X1, typename X2>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1), const P1& p1,
     const P2& p2) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1),
-                               Tuple2<P1, P2>, Tuple1<A1> >
+                               Tuple<P1, P2>, Tuple<A1>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -2154,76 +2154,76 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1), const P1& p1,
 // 2 - 2
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename X1, typename X2>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2), const P1& p1,
     const P2& p2) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, A1, A2),
-                 Tuple2<P1, P2>, Tuple2<A1, A2> >
+                 Tuple<P1, P2>, Tuple<A1, A2>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename A1, typename A2,
           typename X1, typename X2>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(R (*function)(X1, X2, A1, A2), const P1& p1, const P2& p2) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantFunction<R, R (*)(X1, X2, A1, A2),
-                         Tuple2<P1, P2>, Tuple2<A1, A2> >
+                         Tuple<P1, P2>, Tuple<A1, A2>>
           (function, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename X1, typename X2>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2), const P1& p1,
     const P2& p2) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, A1, A2),
-                               Tuple2<P1, P2>, Tuple2<A1, A2> >
+                               Tuple<P1, P2>, Tuple<A1, A2>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
 #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename X1, typename X2>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2), const P1& p1,
     const P2& p2) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1, A2),
-                 Tuple2<P1, P2>, Tuple2<A1, A2> >
+                 Tuple<P1, P2>, Tuple<A1, A2>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename A1, typename A2,
           typename X1, typename X2>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2), const P1& p1,
     const P2& p2) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, A1, A2),
-                         Tuple2<P1, P2>, Tuple2<A1, A2> >
+                         Tuple<P1, P2>, Tuple<A1, A2>>
           (function, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename X1, typename X2>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2), const P1& p1,
     const P2& p2) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1, A2),
-                               Tuple2<P1, P2>, Tuple2<A1, A2> >
+                               Tuple<P1, P2>, Tuple<A1, A2>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -2231,76 +2231,76 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2), const P1& p1,
 // 2 - 3
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename A3, typename X1, typename X2>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2, A3), const P1& p1,
     const P2& p2) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, A1, A2, A3),
-                 Tuple2<P1, P2>, Tuple3<A1, A2, A3> >
+                 Tuple<P1, P2>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename A1, typename A2,
           typename A3, typename X1, typename X2>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(R (*function)(X1, X2, A1, A2, A3), const P1& p1, const P2& p2) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantFunction<R, R (*)(X1, X2, A1, A2, A3),
-                         Tuple2<P1, P2>, Tuple3<A1, A2, A3> >
+                         Tuple<P1, P2>, Tuple<A1, A2, A3>>
           (function, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename A3, typename X1, typename X2>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3), const P1& p1,
     const P2& p2) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, A1, A2, A3),
-                               Tuple2<P1, P2>, Tuple3<A1, A2, A3> >
+                               Tuple<P1, P2>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
 #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename A3, typename X1, typename X2>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3),
     const P1& p1, const P2& p2) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3),
-                 Tuple2<P1, P2>, Tuple3<A1, A2, A3> >
+                 Tuple<P1, P2>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename A1, typename A2,
           typename A3, typename X1, typename X2>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2, A3), const P1& p1,
     const P2& p2) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, A1, A2, A3),
-                         Tuple2<P1, P2>, Tuple3<A1, A2, A3> >
+                         Tuple<P1, P2>, Tuple<A1, A2, A3>>
           (function, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename A3, typename X1, typename X2>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3),
     const P1& p1, const P2& p2) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3),
-                               Tuple2<P1, P2>, Tuple3<A1, A2, A3> >
+                               Tuple<P1, P2>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -2309,40 +2309,40 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3),
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename A3, typename A4, typename X1,
           typename X2>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2, A3, A4), const P1& p1,
     const P2& p2) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, A1, A2, A3, A4),
-                 Tuple2<P1, P2>, Tuple4<A1, A2, A3, A4> >
+                 Tuple<P1, P2>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename A1, typename A2,
           typename A3, typename A4, typename X1, typename X2>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(R (*function)(X1, X2, A1, A2, A3, A4), const P1& p1,
     const P2& p2) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantFunction<R, R (*)(X1, X2, A1, A2, A3, A4),
-                         Tuple2<P1, P2>, Tuple4<A1, A2, A3, A4> >
+                         Tuple<P1, P2>, Tuple<A1, A2, A3, A4>>
           (function, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename A3, typename A4, typename X1,
           typename X2>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4), const P1& p1,
     const P2& p2) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, A1, A2, A3, A4),
-                               Tuple2<P1, P2>, Tuple4<A1, A2, A3, A4> >
+                               Tuple<P1, P2>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -2350,39 +2350,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4), const P1& p1,
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename A3, typename A4, typename X1,
           typename X2>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4),
     const P1& p1, const P2& p2) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4),
-                 Tuple2<P1, P2>, Tuple4<A1, A2, A3, A4> >
+                 Tuple<P1, P2>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename A1, typename A2,
           typename A3, typename A4, typename X1, typename X2>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2, A3, A4), const P1& p1,
     const P2& p2) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, A1, A2, A3, A4),
-                         Tuple2<P1, P2>, Tuple4<A1, A2, A3, A4> >
+                         Tuple<P1, P2>, Tuple<A1, A2, A3, A4>>
           (function, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename A3, typename A4, typename X1,
           typename X2>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4),
     const P1& p1, const P2& p2) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4),
-                               Tuple2<P1, P2>, Tuple4<A1, A2, A3, A4> >
+                               Tuple<P1, P2>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -2391,40 +2391,40 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4),
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename A3, typename A4, typename A5,
           typename X1, typename X2>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5), const P1& p1,
     const P2& p2) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, A1, A2, A3, A4, A5),
-                 Tuple2<P1, P2>, Tuple5<A1, A2, A3, A4, A5> >
+                 Tuple<P1, P2>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename A1, typename A2,
           typename A3, typename A4, typename A5, typename X1, typename X2>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(R (*function)(X1, X2, A1, A2, A3, A4, A5), const P1& p1,
     const P2& p2) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantFunction<R, R (*)(X1, X2, A1, A2, A3, A4, A5),
-                         Tuple2<P1, P2>, Tuple5<A1, A2, A3, A4, A5> >
+                         Tuple<P1, P2>, Tuple<A1, A2, A3, A4, A5>>
           (function, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename A3, typename A4, typename A5,
           typename X1, typename X2>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5), const P1& p1,
     const P2& p2) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, A1, A2, A3, A4, A5),
-                               Tuple2<P1, P2>, Tuple5<A1, A2, A3, A4, A5> >
+                               Tuple<P1, P2>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -2432,39 +2432,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5), const P1& p1,
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename A3, typename A4, typename A5,
           typename X1, typename X2>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5),
     const P1& p1, const P2& p2) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4, A5),
-                 Tuple2<P1, P2>, Tuple5<A1, A2, A3, A4, A5> >
+                 Tuple<P1, P2>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename A1, typename A2,
           typename A3, typename A4, typename A5, typename X1, typename X2>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2, A3, A4, A5), const P1& p1,
     const P2& p2) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, A1, A2, A3, A4, A5),
-                         Tuple2<P1, P2>, Tuple5<A1, A2, A3, A4, A5> >
+                         Tuple<P1, P2>, Tuple<A1, A2, A3, A4, A5>>
           (function, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename A3, typename A4, typename A5,
           typename X1, typename X2>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5),
     const P1& p1, const P2& p2) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4, A5),
-                               Tuple2<P1, P2>, Tuple5<A1, A2, A3, A4, A5> >
+                               Tuple<P1, P2>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -2473,41 +2473,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5),
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename A3, typename A4, typename A5,
           typename A6, typename X1, typename X2>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5, A6),
     const P1& p1, const P2& p2) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, A1, A2, A3, A4, A5, A6),
-                 Tuple2<P1, P2>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                 Tuple<P1, P2>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename A1, typename A2,
           typename A3, typename A4, typename A5, typename A6, typename X1,
           typename X2>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(R (*function)(X1, X2, A1, A2, A3, A4, A5, A6), const P1& p1,
     const P2& p2) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantFunction<R, R (*)(X1, X2, A1, A2, A3, A4, A5, A6),
-                         Tuple2<P1, P2>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                         Tuple<P1, P2>, Tuple<A1, A2, A3, A4, A5, A6>>
           (function, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename A3, typename A4, typename A5,
           typename A6, typename X1, typename X2>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5, A6),
     const P1& p1, const P2& p2) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, A1, A2, A3, A4, A5, A6),
-                               Tuple2<P1, P2>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                               Tuple<P1, P2>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -2515,40 +2515,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5, A6),
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename A3, typename A4, typename A5,
           typename A6, typename X1, typename X2>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5, A6),
     const P1& p1, const P2& p2) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4, A5, A6),
-                 Tuple2<P1, P2>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                 Tuple<P1, P2>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename A1, typename A2,
           typename A3, typename A4, typename A5, typename A6, typename X1,
           typename X2>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2, A3, A4, A5, A6),
     const P1& p1, const P2& p2) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, A1, A2, A3, A4, A5, A6),
-                         Tuple2<P1, P2>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                         Tuple<P1, P2>, Tuple<A1, A2, A3, A4, A5, A6>>
           (function, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename A3, typename A4, typename A5,
           typename A6, typename X1, typename X2>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5, A6),
     const P1& p1, const P2& p2) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4, A5, A6),
-                               Tuple2<P1, P2>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                               Tuple<P1, P2>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -2556,77 +2556,77 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5, A6),
 // 3 - 0
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3), const P1& p1, const P2& p2,
     const P3& p3) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3),
-                 Tuple3<P1, P2, P3>, Tuple0>
+                 Tuple<P1, P2, P3>, Tuple<>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename X1,
           typename X2, typename X3>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(R (*function)(X1, X2, X3), const P1& p1, const P2& p2,
     const P3& p3) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3),
-                         Tuple3<P1, P2, P3>, Tuple0>
+                         Tuple<P1, P2, P3>, Tuple<>>
           (function, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3), const P1& p1, const P2& p2,
     const P3& p3) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3),
-                               Tuple3<P1, P2, P3>, Tuple0>
+                               Tuple<P1, P2, P3>, Tuple<>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
 #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3), const P1& p1,
     const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3),
-                 Tuple3<P1, P2, P3>, Tuple0>
+                 Tuple<P1, P2, P3>, Tuple<>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename X1,
           typename X2, typename X3>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3), const P1& p1, const P2& p2,
     const P3& p3) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3),
-                         Tuple3<P1, P2, P3>, Tuple0>
+                         Tuple<P1, P2, P3>, Tuple<>>
           (function, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3), const P1& p1,
     const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3),
-                               Tuple3<P1, P2, P3>, Tuple0>
+                               Tuple<P1, P2, P3>, Tuple<>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -2634,77 +2634,77 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3), const P1& p1,
 // 3 - 1
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1), const P1& p1,
     const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, A1),
-                 Tuple3<P1, P2, P3>, Tuple1<A1> >
+                 Tuple<P1, P2, P3>, Tuple<A1>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename A1,
           typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(R (*function)(X1, X2, X3, A1), const P1& p1, const P2& p2,
     const P3& p3) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, A1),
-                         Tuple3<P1, P2, P3>, Tuple1<A1> >
+                         Tuple<P1, P2, P3>, Tuple<A1>>
           (function, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1), const P1& p1,
     const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, A1),
-                               Tuple3<P1, P2, P3>, Tuple1<A1> >
+                               Tuple<P1, P2, P3>, Tuple<A1>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
 #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1), const P1& p1,
     const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1),
-                 Tuple3<P1, P2, P3>, Tuple1<A1> >
+                 Tuple<P1, P2, P3>, Tuple<A1>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename A1,
           typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1), const P1& p1,
     const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, A1),
-                         Tuple3<P1, P2, P3>, Tuple1<A1> >
+                         Tuple<P1, P2, P3>, Tuple<A1>>
           (function, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1), const P1& p1,
     const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1),
-                               Tuple3<P1, P2, P3>, Tuple1<A1> >
+                               Tuple<P1, P2, P3>, Tuple<A1>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -2713,40 +2713,40 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1), const P1& p1,
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename A2, typename X1, typename X2,
           typename X3>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2), const P1& p1,
     const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, A1, A2),
-                 Tuple3<P1, P2, P3>, Tuple2<A1, A2> >
+                 Tuple<P1, P2, P3>, Tuple<A1, A2>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename A1,
           typename A2, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(R (*function)(X1, X2, X3, A1, A2), const P1& p1, const P2& p2,
     const P3& p3) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, A1, A2),
-                         Tuple3<P1, P2, P3>, Tuple2<A1, A2> >
+                         Tuple<P1, P2, P3>, Tuple<A1, A2>>
           (function, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename A2, typename X1, typename X2,
           typename X3>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2), const P1& p1,
     const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, A1, A2),
-                               Tuple3<P1, P2, P3>, Tuple2<A1, A2> >
+                               Tuple<P1, P2, P3>, Tuple<A1, A2>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -2754,39 +2754,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2), const P1& p1,
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename A2, typename X1, typename X2,
           typename X3>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2),
     const P1& p1, const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2),
-                 Tuple3<P1, P2, P3>, Tuple2<A1, A2> >
+                 Tuple<P1, P2, P3>, Tuple<A1, A2>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename A1,
           typename A2, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2), const P1& p1,
     const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, A1, A2),
-                         Tuple3<P1, P2, P3>, Tuple2<A1, A2> >
+                         Tuple<P1, P2, P3>, Tuple<A1, A2>>
           (function, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename A2, typename X1, typename X2,
           typename X3>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2),
     const P1& p1, const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2),
-                               Tuple3<P1, P2, P3>, Tuple2<A1, A2> >
+                               Tuple<P1, P2, P3>, Tuple<A1, A2>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -2795,40 +2795,40 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2),
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename A2, typename A3, typename X1,
           typename X2, typename X3>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2, A3), const P1& p1,
     const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, A1, A2, A3),
-                 Tuple3<P1, P2, P3>, Tuple3<A1, A2, A3> >
+                 Tuple<P1, P2, P3>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename A1,
           typename A2, typename A3, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(R (*function)(X1, X2, X3, A1, A2, A3), const P1& p1, const P2& p2,
     const P3& p3) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, A1, A2, A3),
-                         Tuple3<P1, P2, P3>, Tuple3<A1, A2, A3> >
+                         Tuple<P1, P2, P3>, Tuple<A1, A2, A3>>
           (function, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename A2, typename A3, typename X1,
           typename X2, typename X3>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3), const P1& p1,
     const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, A1, A2, A3),
-                               Tuple3<P1, P2, P3>, Tuple3<A1, A2, A3> >
+                               Tuple<P1, P2, P3>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -2836,39 +2836,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3), const P1& p1,
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename A2, typename A3, typename X1,
           typename X2, typename X3>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3),
     const P1& p1, const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3),
-                 Tuple3<P1, P2, P3>, Tuple3<A1, A2, A3> >
+                 Tuple<P1, P2, P3>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename A1,
           typename A2, typename A3, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2, A3), const P1& p1,
     const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, A1, A2, A3),
-                         Tuple3<P1, P2, P3>, Tuple3<A1, A2, A3> >
+                         Tuple<P1, P2, P3>, Tuple<A1, A2, A3>>
           (function, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename A2, typename A3, typename X1,
           typename X2, typename X3>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3),
     const P1& p1, const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3),
-                               Tuple3<P1, P2, P3>, Tuple3<A1, A2, A3> >
+                               Tuple<P1, P2, P3>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -2877,41 +2877,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3),
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename A2, typename A3, typename A4,
           typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4), const P1& p1,
     const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, A1, A2, A3, A4),
-                 Tuple3<P1, P2, P3>, Tuple4<A1, A2, A3, A4> >
+                 Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename A1,
           typename A2, typename A3, typename A4, typename X1, typename X2,
           typename X3>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(R (*function)(X1, X2, X3, A1, A2, A3, A4), const P1& p1,
     const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, A1, A2, A3, A4),
-                         Tuple3<P1, P2, P3>, Tuple4<A1, A2, A3, A4> >
+                         Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4>>
           (function, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename A2, typename A3, typename A4,
           typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4), const P1& p1,
     const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, A1, A2, A3, A4),
-                               Tuple3<P1, P2, P3>, Tuple4<A1, A2, A3, A4> >
+                               Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -2919,40 +2919,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4), const P1& p1,
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename A2, typename A3, typename A4,
           typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4),
     const P1& p1, const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3, A4),
-                 Tuple3<P1, P2, P3>, Tuple4<A1, A2, A3, A4> >
+                 Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename A1,
           typename A2, typename A3, typename A4, typename X1, typename X2,
           typename X3>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2, A3, A4), const P1& p1,
     const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, A1, A2, A3, A4),
-                         Tuple3<P1, P2, P3>, Tuple4<A1, A2, A3, A4> >
+                         Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4>>
           (function, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename A2, typename A3, typename A4,
           typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4),
     const P1& p1, const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3, A4),
-                               Tuple3<P1, P2, P3>, Tuple4<A1, A2, A3, A4> >
+                               Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -2961,41 +2961,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4),
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename A2, typename A3, typename A4,
           typename A5, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5),
     const P1& p1, const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, A1, A2, A3, A4, A5),
-                 Tuple3<P1, P2, P3>, Tuple5<A1, A2, A3, A4, A5> >
+                 Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename A1,
           typename A2, typename A3, typename A4, typename A5, typename X1,
           typename X2, typename X3>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(R (*function)(X1, X2, X3, A1, A2, A3, A4, A5), const P1& p1,
     const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, A1, A2, A3, A4, A5),
-                         Tuple3<P1, P2, P3>, Tuple5<A1, A2, A3, A4, A5> >
+                         Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4, A5>>
           (function, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename A2, typename A3, typename A4,
           typename A5, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5),
     const P1& p1, const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, A1, A2, A3, A4, A5),
-                               Tuple3<P1, P2, P3>, Tuple5<A1, A2, A3, A4, A5> >
+                               Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -3003,40 +3003,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5),
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename A2, typename A3, typename A4,
           typename A5, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5),
     const P1& p1, const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3, A4, A5),
-                 Tuple3<P1, P2, P3>, Tuple5<A1, A2, A3, A4, A5> >
+                 Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename A1,
           typename A2, typename A3, typename A4, typename A5, typename X1,
           typename X2, typename X3>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2, A3, A4, A5),
     const P1& p1, const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, A1, A2, A3, A4, A5),
-                         Tuple3<P1, P2, P3>, Tuple5<A1, A2, A3, A4, A5> >
+                         Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4, A5>>
           (function, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename A2, typename A3, typename A4,
           typename A5, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5),
     const P1& p1, const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3, A4, A5),
-                               Tuple3<P1, P2, P3>, Tuple5<A1, A2, A3, A4, A5> >
+                               Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -3045,41 +3045,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5),
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename A2, typename A3, typename A4,
           typename A5, typename A6, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
     const P1& p1, const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
-                 Tuple3<P1, P2, P3>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                 Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename A1,
           typename A2, typename A3, typename A4, typename A5, typename A6,
           typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(R (*function)(X1, X2, X3, A1, A2, A3, A4, A5, A6), const P1& p1,
     const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
-                         Tuple3<P1, P2, P3>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                         Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4, A5, A6>>
           (function, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename A2, typename A3, typename A4,
           typename A5, typename A6, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
     const P1& p1, const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
-                               Tuple3<P1, P2, P3>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                               Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -3087,40 +3087,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename A2, typename A3, typename A4,
           typename A5, typename A6, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5,
     A6), const P1& p1, const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
-                 Tuple3<P1, P2, P3>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                 Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename A1,
           typename A2, typename A3, typename A4, typename A5, typename A6,
           typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
     const P1& p1, const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
-                         Tuple3<P1, P2, P3>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                         Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4, A5, A6>>
           (function, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename A2, typename A3, typename A4,
           typename A5, typename A6, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5,
     A6), const P1& p1, const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
-                               Tuple3<P1, P2, P3>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                               Tuple<P1, P2, P3>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -3129,40 +3129,40 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5,
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename X1, typename X2, typename X3,
           typename X4>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, X4),
-                 Tuple4<P1, P2, P3, P4>, Tuple0>
+                 Tuple<P1, P2, P3, P4>, Tuple<>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(R (*function)(X1, X2, X3, X4), const P1& p1, const P2& p2,
     const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, X4),
-                         Tuple4<P1, P2, P3, P4>, Tuple0>
+                         Tuple<P1, P2, P3, P4>, Tuple<>>
           (function, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename X1, typename X2, typename X3,
           typename X4>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4),
-                               Tuple4<P1, P2, P3, P4>, Tuple0>
+                               Tuple<P1, P2, P3, P4>, Tuple<>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -3170,39 +3170,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4), const P1& p1,
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename X1, typename X2, typename X3,
           typename X4>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4),
-                 Tuple4<P1, P2, P3, P4>, Tuple0>
+                 Tuple<P1, P2, P3, P4>, Tuple<>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4),
-                         Tuple4<P1, P2, P3, P4>, Tuple0>
+                         Tuple<P1, P2, P3, P4>, Tuple<>>
           (function, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename X1, typename X2, typename X3,
           typename X4>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4),
-                               Tuple4<P1, P2, P3, P4>, Tuple0>
+                               Tuple<P1, P2, P3, P4>, Tuple<>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -3211,40 +3211,40 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4), const P1& p1,
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename X1, typename X2,
           typename X3, typename X4>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, X4, A1),
-                 Tuple4<P1, P2, P3, P4>, Tuple1<A1> >
+                 Tuple<P1, P2, P3, P4>, Tuple<A1>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename A1, typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(R (*function)(X1, X2, X3, X4, A1), const P1& p1, const P2& p2,
     const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, X4, A1),
-                         Tuple4<P1, P2, P3, P4>, Tuple1<A1> >
+                         Tuple<P1, P2, P3, P4>, Tuple<A1>>
           (function, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename X1, typename X2,
           typename X3, typename X4>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, A1),
-                               Tuple4<P1, P2, P3, P4>, Tuple1<A1> >
+                               Tuple<P1, P2, P3, P4>, Tuple<A1>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -3252,39 +3252,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1), const P1& p1,
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename X1, typename X2,
           typename X3, typename X4>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1),
-                 Tuple4<P1, P2, P3, P4>, Tuple1<A1> >
+                 Tuple<P1, P2, P3, P4>, Tuple<A1>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename A1, typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, A1),
-                         Tuple4<P1, P2, P3, P4>, Tuple1<A1> >
+                         Tuple<P1, P2, P3, P4>, Tuple<A1>>
           (function, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename X1, typename X2,
           typename X3, typename X4>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1),
-                               Tuple4<P1, P2, P3, P4>, Tuple1<A1> >
+                               Tuple<P1, P2, P3, P4>, Tuple<A1>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -3293,41 +3293,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1),
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename A2, typename X1,
           typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, X4, A1, A2),
-                 Tuple4<P1, P2, P3, P4>, Tuple2<A1, A2> >
+                 Tuple<P1, P2, P3, P4>, Tuple<A1, A2>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename A1, typename A2, typename X1, typename X2, typename X3,
           typename X4>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(R (*function)(X1, X2, X3, X4, A1, A2), const P1& p1, const P2& p2,
     const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, X4, A1, A2),
-                         Tuple4<P1, P2, P3, P4>, Tuple2<A1, A2> >
+                         Tuple<P1, P2, P3, P4>, Tuple<A1, A2>>
           (function, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename A2, typename X1,
           typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, A1, A2),
-                               Tuple4<P1, P2, P3, P4>, Tuple2<A1, A2> >
+                               Tuple<P1, P2, P3, P4>, Tuple<A1, A2>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -3335,40 +3335,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2), const P1& p1,
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename A2, typename X1,
           typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2),
-                 Tuple4<P1, P2, P3, P4>, Tuple2<A1, A2> >
+                 Tuple<P1, P2, P3, P4>, Tuple<A1, A2>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename A1, typename A2, typename X1, typename X2, typename X3,
           typename X4>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, A1, A2),
-                         Tuple4<P1, P2, P3, P4>, Tuple2<A1, A2> >
+                         Tuple<P1, P2, P3, P4>, Tuple<A1, A2>>
           (function, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename A2, typename X1,
           typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2),
-                               Tuple4<P1, P2, P3, P4>, Tuple2<A1, A2> >
+                               Tuple<P1, P2, P3, P4>, Tuple<A1, A2>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -3377,41 +3377,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2),
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename A2, typename A3,
           typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3),
-                 Tuple4<P1, P2, P3, P4>, Tuple3<A1, A2, A3> >
+                 Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename A1, typename A2, typename A3, typename X1, typename X2,
           typename X3, typename X4>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(R (*function)(X1, X2, X3, X4, A1, A2, A3), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, X4, A1, A2, A3),
-                         Tuple4<P1, P2, P3, P4>, Tuple3<A1, A2, A3> >
+                         Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3>>
           (function, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename A2, typename A3,
           typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3),
-                               Tuple4<P1, P2, P3, P4>, Tuple3<A1, A2, A3> >
+                               Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -3419,40 +3419,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3), const P1& p1,
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename A2, typename A3,
           typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3),
-                 Tuple4<P1, P2, P3, P4>, Tuple3<A1, A2, A3> >
+                 Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename A1, typename A2, typename A3, typename X1, typename X2,
           typename X3, typename X4>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2, A3), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, A1, A2, A3),
-                         Tuple4<P1, P2, P3, P4>, Tuple3<A1, A2, A3> >
+                         Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3>>
           (function, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename A2, typename A3,
           typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3),
-                               Tuple4<P1, P2, P3, P4>, Tuple3<A1, A2, A3> >
+                               Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -3461,41 +3461,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3),
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename A2, typename A3,
           typename A4, typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3, A4),
-                 Tuple4<P1, P2, P3, P4>, Tuple4<A1, A2, A3, A4> >
+                 Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename A1, typename A2, typename A3, typename A4, typename X1,
           typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(R (*function)(X1, X2, X3, X4, A1, A2, A3, A4), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, X4, A1, A2, A3, A4),
-                         Tuple4<P1, P2, P3, P4>, Tuple4<A1, A2, A3, A4> >
+                         Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4>>
           (function, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename A2, typename A3,
           typename A4, typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3, A4),
-                               Tuple4<P1, P2, P3, P4>, Tuple4<A1, A2, A3, A4> >
+                               Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -3503,40 +3503,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4),
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename A2, typename A3,
           typename A4, typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4),
-                 Tuple4<P1, P2, P3, P4>, Tuple4<A1, A2, A3, A4> >
+                 Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename A1, typename A2, typename A3, typename A4, typename X1,
           typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2, A3, A4),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, A1, A2, A3, A4),
-                         Tuple4<P1, P2, P3, P4>, Tuple4<A1, A2, A3, A4> >
+                         Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4>>
           (function, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename A2, typename A3,
           typename A4, typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4),
-                               Tuple4<P1, P2, P3, P4>, Tuple4<A1, A2, A3, A4> >
+                               Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -3546,27 +3546,27 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename A2, typename A3,
           typename A4, typename A5, typename X1, typename X2, typename X3,
           typename X4>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
-                 Tuple4<P1, P2, P3, P4>, Tuple5<A1, A2, A3, A4, A5> >
+                 Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename A1, typename A2, typename A3, typename A4, typename A5,
           typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(R (*function)(X1, X2, X3, X4, A1, A2, A3, A4, A5), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
-                         Tuple4<P1, P2, P3, P4>, Tuple5<A1, A2, A3, A4, A5> >
+                         Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4, A5>>
           (function, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -3574,14 +3574,14 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename A2, typename A3,
           typename A4, typename A5, typename X1, typename X2, typename X3,
           typename X4>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
-                               Tuple4<P1, P2, P3, P4>, Tuple5<A1, A2, A3, A4, A5> >
+                               Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -3590,41 +3590,41 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename A2, typename A3,
           typename A4, typename A5, typename X1, typename X2, typename X3,
           typename X4>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4,
     A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
-                 Tuple4<P1, P2, P3, P4>, Tuple5<A1, A2, A3, A4, A5> >
+                 Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename A1, typename A2, typename A3, typename A4, typename A5,
           typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
-                         Tuple4<P1, P2, P3, P4>, Tuple5<A1, A2, A3, A4, A5> >
+                         Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4, A5>>
           (function, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename A2, typename A3,
           typename A4, typename A5, typename X1, typename X2, typename X3,
           typename X4>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4,
     A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
-                               Tuple4<P1, P2, P3, P4>, Tuple5<A1, A2, A3, A4, A5> >
+                               Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -3634,27 +3634,27 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename A2, typename A3,
           typename A4, typename A5, typename A6, typename X1, typename X2,
           typename X3, typename X4>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
-                 Tuple4<P1, P2, P3, P4>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                 Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename A1, typename A2, typename A3, typename A4, typename A5,
           typename A6, typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(R (*function)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
-                         Tuple4<P1, P2, P3, P4>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                         Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4, A5, A6>>
           (function, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -3662,14 +3662,14 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename A2, typename A3,
           typename A4, typename A5, typename A6, typename X1, typename X2,
           typename X3, typename X4>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
-                               Tuple4<P1, P2, P3, P4>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                               Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -3678,41 +3678,41 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename A2, typename A3,
           typename A4, typename A5, typename A6, typename X1, typename X2,
           typename X3, typename X4>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4,
     A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
-                 Tuple4<P1, P2, P3, P4>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                 Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename A1, typename A2, typename A3, typename A4, typename A5,
           typename A6, typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
-                         Tuple4<P1, P2, P3, P4>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                         Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4, A5, A6>>
           (function, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename A2, typename A3,
           typename A4, typename A5, typename A6, typename X1, typename X2,
           typename X3, typename X4>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4,
     A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6),
-                               Tuple4<P1, P2, P3, P4>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                               Tuple<P1, P2, P3, P4>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -3721,41 +3721,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4,
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename X1, typename X2,
           typename X3, typename X4, typename X5>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5),
-                 Tuple5<P1, P2, P3, P4, P5>, Tuple0>
+                 Tuple<P1, P2, P3, P4, P5>, Tuple<>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename X1, typename X2, typename X3, typename X4,
           typename X5>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(R (*function)(X1, X2, X3, X4, X5), const P1& p1, const P2& p2,
     const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, X4, X5),
-                         Tuple5<P1, P2, P3, P4, P5>, Tuple0>
+                         Tuple<P1, P2, P3, P4, P5>, Tuple<>>
           (function, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename X1, typename X2,
           typename X3, typename X4, typename X5>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5),
-                               Tuple5<P1, P2, P3, P4, P5>, Tuple0>
+                               Tuple<P1, P2, P3, P4, P5>, Tuple<>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -3763,40 +3763,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5), const P1& p1,
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename X1, typename X2,
           typename X3, typename X4, typename X5>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5),
-                 Tuple5<P1, P2, P3, P4, P5>, Tuple0>
+                 Tuple<P1, P2, P3, P4, P5>, Tuple<>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename X1, typename X2, typename X3, typename X4,
           typename X5>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5),
-                         Tuple5<P1, P2, P3, P4, P5>, Tuple0>
+                         Tuple<P1, P2, P3, P4, P5>, Tuple<>>
           (function, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename X1, typename X2,
           typename X3, typename X4, typename X5>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5),
-                               Tuple5<P1, P2, P3, P4, P5>, Tuple0>
+                               Tuple<P1, P2, P3, P4, P5>, Tuple<>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -3805,41 +3805,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5),
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename A1, typename X1,
           typename X2, typename X3, typename X4, typename X5>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1),
-                 Tuple5<P1, P2, P3, P4, P5>, Tuple1<A1> >
+                 Tuple<P1, P2, P3, P4, P5>, Tuple<A1>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename A1, typename X1, typename X2, typename X3,
           typename X4, typename X5>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1), const P1& p1, const P2& p2,
     const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1),
-                         Tuple5<P1, P2, P3, P4, P5>, Tuple1<A1> >
+                         Tuple<P1, P2, P3, P4, P5>, Tuple<A1>>
           (function, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename A1, typename X1,
           typename X2, typename X3, typename X4, typename X5>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1),
-                               Tuple5<P1, P2, P3, P4, P5>, Tuple1<A1> >
+                               Tuple<P1, P2, P3, P4, P5>, Tuple<A1>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -3847,40 +3847,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1), const P1& p1,
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename A1, typename X1,
           typename X2, typename X3, typename X4, typename X5>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1),
-                 Tuple5<P1, P2, P3, P4, P5>, Tuple1<A1> >
+                 Tuple<P1, P2, P3, P4, P5>, Tuple<A1>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename A1, typename X1, typename X2, typename X3,
           typename X4, typename X5>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1),
-                         Tuple5<P1, P2, P3, P4, P5>, Tuple1<A1> >
+                         Tuple<P1, P2, P3, P4, P5>, Tuple<A1>>
           (function, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename A1, typename X1,
           typename X2, typename X3, typename X4, typename X5>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1),
-                               Tuple5<P1, P2, P3, P4, P5>, Tuple1<A1> >
+                               Tuple<P1, P2, P3, P4, P5>, Tuple<A1>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -3889,41 +3889,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1),
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename A1, typename A2,
           typename X1, typename X2, typename X3, typename X4, typename X5>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2),
-                 Tuple5<P1, P2, P3, P4, P5>, Tuple2<A1, A2> >
+                 Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename A1, typename A2, typename X1, typename X2,
           typename X3, typename X4, typename X5>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1, A2), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1, A2),
-                         Tuple5<P1, P2, P3, P4, P5>, Tuple2<A1, A2> >
+                         Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2>>
           (function, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename A1, typename A2,
           typename X1, typename X2, typename X3, typename X4, typename X5>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2),
-                               Tuple5<P1, P2, P3, P4, P5>, Tuple2<A1, A2> >
+                               Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -3931,40 +3931,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2), const P1& p1,
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename A1, typename A2,
           typename X1, typename X2, typename X3, typename X4, typename X5>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2),
-                 Tuple5<P1, P2, P3, P4, P5>, Tuple2<A1, A2> >
+                 Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename A1, typename A2, typename X1, typename X2,
           typename X3, typename X4, typename X5>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1, A2), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1, A2),
-                         Tuple5<P1, P2, P3, P4, P5>, Tuple2<A1, A2> >
+                         Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2>>
           (function, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename A1, typename A2,
           typename X1, typename X2, typename X3, typename X4, typename X5>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2),
-                               Tuple5<P1, P2, P3, P4, P5>, Tuple2<A1, A2> >
+                               Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -3974,27 +3974,27 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename A1, typename A2,
           typename A3, typename X1, typename X2, typename X3, typename X4,
           typename X5>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3),
-                 Tuple5<P1, P2, P3, P4, P5>, Tuple3<A1, A2, A3> >
+                 Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename A1, typename A2, typename A3, typename X1,
           typename X2, typename X3, typename X4, typename X5>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1, A2, A3), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1, A2, A3),
-                         Tuple5<P1, P2, P3, P4, P5>, Tuple3<A1, A2, A3> >
+                         Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3>>
           (function, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4002,14 +4002,14 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename A1, typename A2,
           typename A3, typename X1, typename X2, typename X3, typename X4,
           typename X5>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3),
-                               Tuple5<P1, P2, P3, P4, P5>, Tuple3<A1, A2, A3> >
+                               Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -4018,41 +4018,41 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename A1, typename A2,
           typename A3, typename X1, typename X2, typename X3, typename X4,
           typename X5>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3),
-                 Tuple5<P1, P2, P3, P4, P5>, Tuple3<A1, A2, A3> >
+                 Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename A1, typename A2, typename A3, typename X1,
           typename X2, typename X3, typename X4, typename X5>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1, A2, A3),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1, A2, A3),
-                         Tuple5<P1, P2, P3, P4, P5>, Tuple3<A1, A2, A3> >
+                         Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3>>
           (function, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename A1, typename A2,
           typename A3, typename X1, typename X2, typename X3, typename X4,
           typename X5>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3),
-                               Tuple5<P1, P2, P3, P4, P5>, Tuple3<A1, A2, A3> >
+                               Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -4062,27 +4062,27 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename A1, typename A2,
           typename A3, typename A4, typename X1, typename X2, typename X3,
           typename X4, typename X5>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
-                 Tuple5<P1, P2, P3, P4, P5>, Tuple4<A1, A2, A3, A4> >
+                 Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename A1, typename A2, typename A3, typename A4,
           typename X1, typename X2, typename X3, typename X4, typename X5>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1, A2, A3, A4), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
-                         Tuple5<P1, P2, P3, P4, P5>, Tuple4<A1, A2, A3, A4> >
+                         Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4>>
           (function, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4090,14 +4090,14 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename A1, typename A2,
           typename A3, typename A4, typename X1, typename X2, typename X3,
           typename X4, typename X5>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
-                               Tuple5<P1, P2, P3, P4, P5>, Tuple4<A1, A2, A3, A4> >
+                               Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -4106,43 +4106,43 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename A1, typename A2,
           typename A3, typename A4, typename X1, typename X2, typename X3,
           typename X4, typename X5>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3,
     A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
     const P5& p5) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
-                 Tuple5<P1, P2, P3, P4, P5>, Tuple4<A1, A2, A3, A4> >
+                 Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename A1, typename A2, typename A3, typename A4,
           typename X1, typename X2, typename X3, typename X4, typename X5>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
-                         Tuple5<P1, P2, P3, P4, P5>, Tuple4<A1, A2, A3, A4> >
+                         Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4>>
           (function, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename A1, typename A2,
           typename A3, typename A4, typename X1, typename X2, typename X3,
           typename X4, typename X5>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3,
     A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
     const P5& p5) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
-                               Tuple5<P1, P2, P3, P4, P5>, Tuple4<A1, A2, A3, A4> >
+                               Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -4152,28 +4152,28 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename A1, typename A2,
           typename A3, typename A4, typename A5, typename X1, typename X2,
           typename X3, typename X4, typename X5>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
-                 Tuple5<P1, P2, P3, P4, P5>, Tuple5<A1, A2, A3, A4, A5> >
+                 Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename A1, typename A2, typename A3, typename A4,
           typename A5, typename X1, typename X2, typename X3, typename X4,
           typename X5>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
-                         Tuple5<P1, P2, P3, P4, P5>, Tuple5<A1, A2, A3, A4, A5> >
+                         Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4, A5>>
           (function, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4181,14 +4181,14 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename A1, typename A2,
           typename A3, typename A4, typename A5, typename X1, typename X2,
           typename X3, typename X4, typename X5>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
-                               Tuple5<P1, P2, P3, P4, P5>, Tuple5<A1, A2, A3, A4, A5> >
+                               Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -4197,44 +4197,44 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename A1, typename A2,
           typename A3, typename A4, typename A5, typename X1, typename X2,
           typename X3, typename X4, typename X5>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3,
     A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
     const P5& p5) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
-                 Tuple5<P1, P2, P3, P4, P5>, Tuple5<A1, A2, A3, A4, A5> >
+                 Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename A1, typename A2, typename A3, typename A4,
           typename A5, typename X1, typename X2, typename X3, typename X4,
           typename X5>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
-                         Tuple5<P1, P2, P3, P4, P5>, Tuple5<A1, A2, A3, A4, A5> >
+                         Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4, A5>>
           (function, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename A1, typename A2,
           typename A3, typename A4, typename A5, typename X1, typename X2,
           typename X3, typename X4, typename X5>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3,
     A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
     const P5& p5) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5),
-                               Tuple5<P1, P2, P3, P4, P5>, Tuple5<A1, A2, A3, A4, A5> >
+                               Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -4244,29 +4244,29 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename A1, typename A2,
           typename A3, typename A4, typename A5, typename A6, typename X1,
           typename X2, typename X3, typename X4, typename X5>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5,
     A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
     const P5& p5) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6),
-                 Tuple5<P1, P2, P3, P4, P5>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                 Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename A1, typename A2, typename A3, typename A4,
           typename A5, typename A6, typename X1, typename X2, typename X3,
           typename X4, typename X5>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6),
-                         Tuple5<P1, P2, P3, P4, P5>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                         Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4, A5, A6>>
           (function, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4274,15 +4274,15 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename A1, typename A2,
           typename A3, typename A4, typename A5, typename A6, typename X1,
           typename X2, typename X3, typename X4, typename X5>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5,
     A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
     const P5& p5) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6),
-                               Tuple5<P1, P2, P3, P4, P5>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                               Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -4291,45 +4291,45 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename A1, typename A2,
           typename A3, typename A4, typename A5, typename A6, typename X1,
           typename X2, typename X3, typename X4, typename X5>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3,
     A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
     const P5& p5) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6),
-                 Tuple5<P1, P2, P3, P4, P5>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                 Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename A1, typename A2, typename A3, typename A4,
           typename A5, typename A6, typename X1, typename X2, typename X3,
           typename X4, typename X5>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5,
     A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
     const P5& p5) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6),
-                         Tuple5<P1, P2, P3, P4, P5>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                         Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4, A5, A6>>
           (function, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename A1, typename A2,
           typename A3, typename A4, typename A5, typename A6, typename X1,
           typename X2, typename X3, typename X4, typename X5>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3,
     A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
     const P5& p5) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6),
-                               Tuple5<P1, P2, P3, P4, P5>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                               Tuple<P1, P2, P3, P4, P5>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -4338,41 +4338,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3,
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename X1,
           typename X2, typename X3, typename X4, typename X5, typename X6>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6),
-                 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple0>
+                 Tuple<P1, P2, P3, P4, P5, P6>, Tuple<>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename P6, typename X1, typename X2, typename X3,
           typename X4, typename X5, typename X6>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6), const P1& p1, const P2& p2,
     const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6),
-                         Tuple6<P1, P2, P3, P4, P5, P6>, Tuple0>
+                         Tuple<P1, P2, P3, P4, P5, P6>, Tuple<>>
           (function, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename X1,
           typename X2, typename X3, typename X4, typename X5, typename X6>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6),
-                               Tuple6<P1, P2, P3, P4, P5, P6>, Tuple0>
+                               Tuple<P1, P2, P3, P4, P5, P6>, Tuple<>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -4380,42 +4380,42 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6), const P1& p1,
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename X1,
           typename X2, typename X3, typename X4, typename X5, typename X6>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
     const P6& p6) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6),
-                 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple0>
+                 Tuple<P1, P2, P3, P4, P5, P6>, Tuple<>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename P6, typename X1, typename X2, typename X3,
           typename X4, typename X5, typename X6>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6),
-                         Tuple6<P1, P2, P3, P4, P5, P6>, Tuple0>
+                         Tuple<P1, P2, P3, P4, P5, P6>, Tuple<>>
           (function, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename X1,
           typename X2, typename X3, typename X4, typename X5, typename X6>
-inline MutantFunctor<R, Tuple0>
+inline MutantFunctor<R, Tuple<>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
     const P6& p6) {
-  MutantRunner<R, Tuple0>* t =
+  MutantRunner<R, Tuple<>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6),
-                               Tuple6<P1, P2, P3, P4, P5, P6>, Tuple0>
+                               Tuple<P1, P2, P3, P4, P5, P6>, Tuple<>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple0>(t);
+  return MutantFunctor<R, Tuple<>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -4425,27 +4425,27 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename A1,
           typename X1, typename X2, typename X3, typename X4, typename X5,
           typename X6>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1),
-                 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple1<A1> >
+                 Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename P6, typename A1, typename X1, typename X2,
           typename X3, typename X4, typename X5, typename X6>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1),
-                         Tuple6<P1, P2, P3, P4, P5, P6>, Tuple1<A1> >
+                         Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1>>
           (function, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4453,14 +4453,14 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename A1,
           typename X1, typename X2, typename X3, typename X4, typename X5,
           typename X6>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1),
-                               Tuple6<P1, P2, P3, P4, P5, P6>, Tuple1<A1> >
+                               Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -4469,43 +4469,43 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename A1,
           typename X1, typename X2, typename X3, typename X4, typename X5,
           typename X6>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
     const P6& p6) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1),
-                 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple1<A1> >
+                 Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename P6, typename A1, typename X1, typename X2,
           typename X3, typename X4, typename X5, typename X6>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1),
-                         Tuple6<P1, P2, P3, P4, P5, P6>, Tuple1<A1> >
+                         Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1>>
           (function, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename A1,
           typename X1, typename X2, typename X3, typename X4, typename X5,
           typename X6>
-inline MutantFunctor<R, Tuple1<A1> >
+inline MutantFunctor<R, Tuple<A1>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
     const P6& p6) {
-  MutantRunner<R, Tuple1<A1> >* t =
+  MutantRunner<R, Tuple<A1>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1),
-                               Tuple6<P1, P2, P3, P4, P5, P6>, Tuple1<A1> >
+                               Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple1<A1> >(t);
+  return MutantFunctor<R, Tuple<A1>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -4515,28 +4515,28 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename A1,
           typename A2, typename X1, typename X2, typename X3, typename X4,
           typename X5, typename X6>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
     const P6& p6) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2),
-                 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple2<A1, A2> >
+                 Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename P6, typename A1, typename A2, typename X1,
           typename X2, typename X3, typename X4, typename X5, typename X6>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1, A2), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1, A2),
-                         Tuple6<P1, P2, P3, P4, P5, P6>, Tuple2<A1, A2> >
+                         Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2>>
           (function, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4544,15 +4544,15 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename A1,
           typename A2, typename X1, typename X2, typename X3, typename X4,
           typename X5, typename X6>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
     const P6& p6) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2),
-                               Tuple6<P1, P2, P3, P4, P5, P6>, Tuple2<A1, A2> >
+                               Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -4561,44 +4561,44 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename A1,
           typename A2, typename X1, typename X2, typename X3, typename X4,
           typename X5, typename X6>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
     const P6& p6) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2),
-                 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple2<A1, A2> >
+                 Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename P6, typename A1, typename A2, typename X1,
           typename X2, typename X3, typename X4, typename X5, typename X6>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1, A2),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
     const P6& p6) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1, A2),
-                         Tuple6<P1, P2, P3, P4, P5, P6>, Tuple2<A1, A2> >
+                         Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2>>
           (function, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename A1,
           typename A2, typename X1, typename X2, typename X3, typename X4,
           typename X5, typename X6>
-inline MutantFunctor<R, Tuple2<A1, A2> >
+inline MutantFunctor<R, Tuple<A1, A2>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
     const P6& p6) {
-  MutantRunner<R, Tuple2<A1, A2> >* t =
+  MutantRunner<R, Tuple<A1, A2>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2),
-                               Tuple6<P1, P2, P3, P4, P5, P6>, Tuple2<A1, A2> >
+                               Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+  return MutantFunctor<R, Tuple<A1, A2>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -4608,29 +4608,29 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename A1,
           typename A2, typename A3, typename X1, typename X2, typename X3,
           typename X4, typename X5, typename X6>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
     const P6& p6) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
-                 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple3<A1, A2, A3> >
+                 Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename P6, typename A1, typename A2, typename A3,
           typename X1, typename X2, typename X3, typename X4, typename X5,
           typename X6>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1, A2, A3), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
-                         Tuple6<P1, P2, P3, P4, P5, P6>, Tuple3<A1, A2, A3> >
+                         Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3>>
           (function, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4638,15 +4638,15 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename A1,
           typename A2, typename A3, typename X1, typename X2, typename X3,
           typename X4, typename X5, typename X6>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
     const P6& p6) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
-                               Tuple6<P1, P2, P3, P4, P5, P6>, Tuple3<A1, A2, A3> >
+                               Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -4655,45 +4655,45 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename A1,
           typename A2, typename A3, typename X1, typename X2, typename X3,
           typename X4, typename X5, typename X6>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2,
     A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
     const P6& p6) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
-                 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple3<A1, A2, A3> >
+                 Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename P6, typename A1, typename A2, typename A3,
           typename X1, typename X2, typename X3, typename X4, typename X5,
           typename X6>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
     const P6& p6) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
-                         Tuple6<P1, P2, P3, P4, P5, P6>, Tuple3<A1, A2, A3> >
+                         Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3>>
           (function, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename A1,
           typename A2, typename A3, typename X1, typename X2, typename X3,
           typename X4, typename X5, typename X6>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+inline MutantFunctor<R, Tuple<A1, A2, A3>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2,
     A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
     const P6& p6) {
-  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
-                               Tuple6<P1, P2, P3, P4, P5, P6>, Tuple3<A1, A2, A3> >
+                               Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -4703,30 +4703,30 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename A1,
           typename A2, typename A3, typename A4, typename X1, typename X2,
           typename X3, typename X4, typename X5, typename X6>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
     const P6& p6) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
-                 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple4<A1, A2, A3, A4> >
+                 Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename P6, typename A1, typename A2, typename A3,
           typename A4, typename X1, typename X2, typename X3, typename X4,
           typename X5, typename X6>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
     const P6& p6) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
-                         Tuple6<P1, P2, P3, P4, P5, P6>, Tuple4<A1, A2, A3, A4> >
+                         Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4>>
           (function, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4734,15 +4734,15 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename A1,
           typename A2, typename A3, typename A4, typename X1, typename X2,
           typename X3, typename X4, typename X5, typename X6>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
     const P6& p6) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
-                               Tuple6<P1, P2, P3, P4, P5, P6>, Tuple4<A1, A2, A3, A4> >
+                               Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -4751,45 +4751,45 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename A1,
           typename A2, typename A3, typename A4, typename X1, typename X2,
           typename X3, typename X4, typename X5, typename X6>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2,
     A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
     const P5& p5, const P6& p6) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
-                 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple4<A1, A2, A3, A4> >
+                 Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename P6, typename A1, typename A2, typename A3,
           typename A4, typename X1, typename X2, typename X3, typename X4,
           typename X5, typename X6>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
     const P6& p6) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
-                         Tuple6<P1, P2, P3, P4, P5, P6>, Tuple4<A1, A2, A3, A4> >
+                         Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4>>
           (function, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename A1,
           typename A2, typename A3, typename A4, typename X1, typename X2,
           typename X3, typename X4, typename X5, typename X6>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2,
     A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
     const P5& p5, const P6& p6) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4),
-                               Tuple6<P1, P2, P3, P4, P5, P6>, Tuple4<A1, A2, A3, A4> >
+                               Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -4799,30 +4799,30 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename A1,
           typename A2, typename A3, typename A4, typename A5, typename X1,
           typename X2, typename X3, typename X4, typename X5, typename X6>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4,
     A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
     const P6& p6) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
-                 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple5<A1, A2, A3, A4, A5> >
+                 Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename P6, typename A1, typename A2, typename A3,
           typename A4, typename A5, typename X1, typename X2, typename X3,
           typename X4, typename X5, typename X6>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
     const P6& p6) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
-                         Tuple6<P1, P2, P3, P4, P5, P6>, Tuple5<A1, A2, A3, A4, A5> >
+                         Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4, A5>>
           (function, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4830,15 +4830,15 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename A1,
           typename A2, typename A3, typename A4, typename A5, typename X1,
           typename X2, typename X3, typename X4, typename X5, typename X6>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4,
     A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
     const P6& p6) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
-                               Tuple6<P1, P2, P3, P4, P5, P6>, Tuple5<A1, A2, A3, A4, A5> >
+                               Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -4847,45 +4847,45 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename A1,
           typename A2, typename A3, typename A4, typename A5, typename X1,
           typename X2, typename X3, typename X4, typename X5, typename X6>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2,
     A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
     const P5& p5, const P6& p6) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
-                 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple5<A1, A2, A3, A4, A5> >
+                 Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename P6, typename A1, typename A2, typename A3,
           typename A4, typename A5, typename X1, typename X2, typename X3,
           typename X4, typename X5, typename X6>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4,
     A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
     const P6& p6) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
-                         Tuple6<P1, P2, P3, P4, P5, P6>, Tuple5<A1, A2, A3, A4, A5> >
+                         Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4, A5>>
           (function, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename P5, typename P6, typename A1,
           typename A2, typename A3, typename A4, typename A5, typename X1,
           typename X2, typename X3, typename X4, typename X5, typename X6>
-inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2,
     A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
     const P5& p5, const P6& p6) {
-  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5),
-                               Tuple6<P1, P2, P3, P4, P5, P6>, Tuple5<A1, A2, A3, A4, A5> >
+                               Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4, A5>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
@@ -4896,30 +4896,30 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename A2, typename A3, typename A4, typename A5, typename A6,
           typename X1, typename X2, typename X3, typename X4, typename X5,
           typename X6>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5,
     A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
     const P6& p6) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6),
-                 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                 Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename P6, typename A1, typename A2, typename A3,
           typename A4, typename A5, typename A6, typename X1, typename X2,
           typename X3, typename X4, typename X5, typename X6>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
     const P6& p6) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6),
-                         Tuple6<P1, P2, P3, P4, P5, P6>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                         Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4, A5, A6>>
           (function, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
@@ -4928,15 +4928,15 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename A2, typename A3, typename A4, typename A5, typename A6,
           typename X1, typename X2, typename X3, typename X4, typename X5,
           typename X6>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5,
     A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5,
     const P6& p6) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6),
-                               Tuple6<P1, P2, P3, P4, P5, P6>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                               Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
@@ -4946,30 +4946,30 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename A2, typename A3, typename A4, typename A5, typename A6,
           typename X1, typename X2, typename X3, typename X4, typename X5,
           typename X6>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2,
     A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
     const P5& p5, const P6& p6) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6),
-                 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                 Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 
 template <typename R, typename P1, typename P2, typename P3, typename P4,
           typename P5, typename P6, typename A1, typename A2, typename A3,
           typename A4, typename A5, typename A6, typename X1, typename X2,
           typename X3, typename X4, typename X5, typename X6>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4,
     A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
     const P5& p5, const P6& p6) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6),
-                         Tuple6<P1, P2, P3, P4, P5, P6>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                         Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4, A5, A6>>
           (function, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 template <typename R, typename T, typename U, typename P1, typename P2,
@@ -4977,15 +4977,15 @@ template <typename R, typename T, typename U, typename P1, typename P2,
           typename A2, typename A3, typename A4, typename A5, typename A6,
           typename X1, typename X2, typename X3, typename X4, typename X5,
           typename X6>
-inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
+inline MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>
 CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2,
     A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4,
     const P5& p5, const P6& p6) {
-  MutantRunner<R, Tuple6<A1, A2, A3, A4, A5, A6> >* t =
+  MutantRunner<R, Tuple<A1, A2, A3, A4, A5, A6>>* t =
       new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6),
-                               Tuple6<P1, P2, P3, P4, P5, P6>, Tuple6<A1, A2, A3, A4, A5, A6> >
+                               Tuple<P1, P2, P3, P4, P5, P6>, Tuple<A1, A2, A3, A4, A5, A6>>
           (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
-  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+  return MutantFunctor<R, Tuple<A1, A2, A3, A4, A5, A6>>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)