First batch of context menu tests

Refactored various methods to send keyboard and mouse
input. Fixed the context menu focus issue on IE7.
Improved existing tests to make them less flaky and
added 3 new tests for context menu items.


BUG=34673
TEST=new tests added


Review URL: http://codereview.chromium.org/604014

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@38905 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 2494 insertions, 4 deletions

diff --git a/testing/generate_gmock_mutant.py b/testing/generate_gmock_mutant.py
index 14ca190..83fbb48 100644
--- a/testing/generate_gmock_mutant.py
+++ b/testing/generate_gmock_mutant.py
@@ -439,12 +439,12 @@ def GenerateCreateFunctor(prebound, calltime):
 
 def main():
   print HEADER
-  for prebound in xrange(0, 4 + 1):
-    for args in xrange(0, 4 + 1):
+  for prebound in xrange(0, 6 + 1):
+    for args in xrange(0, 6 + 1):
       GenerateDispatch(prebound, args)
   print MUTANT
-  for prebound in xrange(0, 4 + 1):
-    for args in xrange(0, 4 + 1):
+  for prebound in xrange(0, 6 + 1):
+    for args in xrange(0, 6 + 1):
       GenerateCreateFunctor(prebound, args)
   print FOOTER
 
diff --git a/testing/gmock_mutant.h b/testing/gmock_mutant.h
index 897d68a..b90bf7b 100644
--- a/testing/gmock_mutant.h
+++ b/testing/gmock_mutant.h
@@ -181,6 +181,38 @@ inline R DispatchToFunction(Function function,
   return (*function)(c.a, c.b, c.c, c.d);
 }
 
+// 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);
+}
+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);
+}
+
+// 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);
+}
+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);
+}
+
 // 1 - 0
 template <typename R, typename T, typename Method, typename P1>
 inline R DispatchToMethod(T* obj, Method method,
@@ -256,6 +288,38 @@ inline R DispatchToFunction(Function function,
   return (*function)(p.a, c.a, c.b, c.c, c.d);
 }
 
+// 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);
+}
+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);
+}
+
+// 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);
+}
+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);
+}
+
 // 2 - 0
 template <typename R, typename T, typename Method, typename P1, typename P2>
 inline R DispatchToMethod(T* obj, Method method,
@@ -333,6 +397,39 @@ inline R DispatchToFunction(Function function,
   return (*function)(p.a, p.b, c.a, c.b, c.c, c.d);
 }
 
+// 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);
+}
+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);
+}
+
+// 2 - 6
+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);
+}
+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);
+}
+
 // 3 - 0
 template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3>
@@ -412,6 +509,41 @@ inline R DispatchToFunction(Function function,
   return (*function)(p.a, p.b, p.c, c.a, c.b, c.c, c.d);
 }
 
+// 3 - 5
+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);
+}
+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);
+}
+
+// 3 - 6
+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);
+}
+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);
+}
+
 // 4 - 0
 template <typename R, typename T, typename Method, typename P1, typename P2,
           typename P3, typename P4>
@@ -493,6 +625,282 @@ inline R DispatchToFunction(Function function,
   return (*function)(p.a, p.b, p.c, p.d, c.a, c.b, c.c, c.d);
 }
 
+// 4 - 5
+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);
+}
+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);
+}
+
+// 4 - 6
+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);
+}
+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);
+}
+
+// 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);
+}
+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);
+}
+
+// 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);
+}
+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);
+}
+
+// 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);
+}
+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);
+}
+
+// 5 - 3
+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);
+}
+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);
+}
+
+// 5 - 4
+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);
+}
+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);
+}
+
+// 5 - 5
+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);
+}
+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);
+}
+
+// 5 - 6
+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);
+}
+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);
+}
+
+// 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);
+}
+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);
+}
+
+// 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);
+}
+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);
+}
+
+// 6 - 2
+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);
+}
+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);
+}
+
+// 6 - 3
+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);
+}
+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);
+}
+
+// 6 - 4
+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);
+}
+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);
+}
+
+// 6 - 5
+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);
+}
+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);
+}
+
+// 6 - 6
+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);
+}
+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);
+}
+
 // Interface that is exposed to the consumer, that does the actual calling
 // of the method.
 template <typename R, typename Params>
@@ -945,6 +1353,150 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4)) {
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
+// 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> >
+CreateFunctor(T* obj, R (U::*method)(A1, A2, A3, A4, A5)) {
+  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+      new Mutant<R, T, R (U::*)(A1, A2, A3, A4, A5),
+                 Tuple0, Tuple5<A1, A2, A3, A4, A5> >
+          (obj, method, MakeTuple());
+  return MutantFunctor<R, Tuple5<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> >
+CreateFunctor(R (*function)(A1, A2, A3, A4, A5)) {
+  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+      new MutantFunction<R, R (*)(A1, A2, A3, A4, A5),
+                         Tuple0, Tuple5<A1, A2, A3, A4, A5> >
+          (function, MakeTuple());
+  return MutantFunctor<R, Tuple5<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> >
+CreateFunctor(T** obj, R (U::*method)(A1, A2, A3, A4, A5)) {
+  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+      new MutantLateObjectBind<R, T, R (U::*)(A1, A2, A3, A4, A5),
+                               Tuple0, Tuple5<A1, A2, A3, A4, A5> >
+          (obj, method, MakeTuple());
+  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+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> >
+CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5)) {
+  MutantRunner<R, Tuple5<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> >
+          (obj, method, MakeTuple());
+  return MutantFunctor<R, Tuple5<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> >
+CreateFunctor(R (__stdcall *function)(A1, A2, A3, A4, A5)) {
+  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+      new MutantFunction<R, R (__stdcall *)(A1, A2, A3, A4, A5),
+                         Tuple0, Tuple5<A1, A2, A3, A4, A5> >
+          (function, MakeTuple());
+  return MutantFunctor<R, Tuple5<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> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5)) {
+  MutantRunner<R, Tuple5<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> >
+          (obj, method, MakeTuple());
+  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif  // OS_WIN
+
+// 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> >
+CreateFunctor(T* obj, R (U::*method)(A1, A2, A3, A4, A5, A6)) {
+  MutantRunner<R, Tuple6<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> >
+          (obj, method, MakeTuple());
+  return MutantFunctor<R, Tuple6<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> >
+CreateFunctor(R (*function)(A1, A2, A3, A4, A5, A6)) {
+  MutantRunner<R, Tuple6<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> >
+          (function, MakeTuple());
+  return MutantFunctor<R, Tuple6<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> >
+CreateFunctor(T** obj, R (U::*method)(A1, A2, A3, A4, A5, A6)) {
+  MutantRunner<R, Tuple6<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> >
+          (obj, method, MakeTuple());
+  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+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> >
+CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5, A6)) {
+  MutantRunner<R, Tuple6<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> >
+          (obj, method, MakeTuple());
+  return MutantFunctor<R, Tuple6<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> >
+CreateFunctor(R (__stdcall *function)(A1, A2, A3, A4, A5, A6)) {
+  MutantRunner<R, Tuple6<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> >
+          (function, MakeTuple());
+  return MutantFunctor<R, Tuple6<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> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5, A6)) {
+  MutantRunner<R, Tuple6<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> >
+          (obj, method, MakeTuple());
+  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif  // OS_WIN
+
 // 1 - 0
 template <typename R, typename T, typename U, typename P1, typename X1>
 inline MutantFunctor<R, Tuple0>
@@ -1297,6 +1849,161 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4),
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
+// 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> >
+CreateFunctor(T* obj, R (U::*method)(X1, A1, A2, A3, A4, A5), const P1& p1) {
+  MutantRunner<R, Tuple5<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> >
+          (obj, method, MakeTuple(p1));
+  return MutantFunctor<R, Tuple5<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> >
+CreateFunctor(R (*function)(X1, A1, A2, A3, A4, A5), const P1& p1) {
+  MutantRunner<R, Tuple5<A1, A2, A3, A4, A5> >* t =
+      new MutantFunction<R, R (*)(X1, A1, A2, A3, A4, A5),
+                         Tuple1<P1>, Tuple5<A1, A2, A3, A4, A5> >
+          (function, MakeTuple(p1));
+  return MutantFunctor<R, Tuple5<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> >
+CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3, A4, A5), const P1& p1) {
+  MutantRunner<R, Tuple5<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> >
+          (obj, method, MakeTuple(p1));
+  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+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> >
+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 =
+      new Mutant<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4, A5),
+                 Tuple1<P1>, Tuple5<A1, A2, A3, A4, A5> >
+          (obj, method, MakeTuple(p1));
+  return MutantFunctor<R, Tuple5<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> >
+CreateFunctor(R (__stdcall *function)(X1, A1, A2, A3, A4, A5), const P1& p1) {
+  MutantRunner<R, Tuple5<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> >
+          (function, MakeTuple(p1));
+  return MutantFunctor<R, Tuple5<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> >
+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 =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4, A5),
+                               Tuple1<P1>, Tuple5<A1, A2, A3, A4, A5> >
+          (obj, method, MakeTuple(p1));
+  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif  // OS_WIN
+
+// 1 - 6
+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> >
+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 =
+      new Mutant<R, T, R (U::*)(X1, A1, A2, A3, A4, A5, A6),
+                 Tuple1<P1>, Tuple6<A1, A2, A3, A4, A5, A6> >
+          (obj, method, MakeTuple(p1));
+  return MutantFunctor<R, Tuple6<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> >
+CreateFunctor(R (*function)(X1, A1, A2, A3, A4, A5, A6), const P1& p1) {
+  MutantRunner<R, Tuple6<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> >
+          (function, MakeTuple(p1));
+  return MutantFunctor<R, Tuple6<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> >
+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 =
+      new MutantLateObjectBind<R, T, R (U::*)(X1, A1, A2, A3, A4, A5, A6),
+                               Tuple1<P1>, Tuple6<A1, A2, A3, A4, A5, A6> >
+          (obj, method, MakeTuple(p1));
+  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+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> >
+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 =
+      new Mutant<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4, A5, A6),
+                 Tuple1<P1>, Tuple6<A1, A2, A3, A4, A5, A6> >
+          (obj, method, MakeTuple(p1));
+  return MutantFunctor<R, Tuple6<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> >
+CreateFunctor(R (__stdcall *function)(X1, A1, A2, A3, A4, A5, A6),
+    const P1& p1) {
+  MutantRunner<R, Tuple6<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> >
+          (function, MakeTuple(p1));
+  return MutantFunctor<R, Tuple6<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> >
+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 =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4, A5, A6),
+                               Tuple1<P1>, Tuple6<A1, A2, A3, A4, A5, A6> >
+          (obj, method, MakeTuple(p1));
+  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif  // OS_WIN
+
 // 2 - 0
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename X1, typename X2>
@@ -1680,6 +2387,172 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4),
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
+// 2 - 5
+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> >
+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 =
+      new Mutant<R, T, R (U::*)(X1, X2, A1, A2, A3, A4, A5),
+                 Tuple2<P1, P2>, Tuple5<A1, A2, A3, A4, A5> >
+          (obj, method, MakeTuple(p1, p2));
+  return MutantFunctor<R, Tuple5<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> >
+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 =
+      new MutantFunction<R, R (*)(X1, X2, A1, A2, A3, A4, A5),
+                         Tuple2<P1, P2>, Tuple5<A1, A2, A3, A4, A5> >
+          (function, MakeTuple(p1, p2));
+  return MutantFunctor<R, Tuple5<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> >
+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 =
+      new MutantLateObjectBind<R, T, R (U::*)(X1, X2, A1, A2, A3, A4, A5),
+                               Tuple2<P1, P2>, Tuple5<A1, A2, A3, A4, A5> >
+          (obj, method, MakeTuple(p1, p2));
+  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+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> >
+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 =
+      new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4, A5),
+                 Tuple2<P1, P2>, Tuple5<A1, A2, A3, A4, A5> >
+          (obj, method, MakeTuple(p1, p2));
+  return MutantFunctor<R, Tuple5<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> >
+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 =
+      new MutantFunction<R, R (__stdcall *)(X1, X2, A1, A2, A3, A4, A5),
+                         Tuple2<P1, P2>, Tuple5<A1, A2, A3, A4, A5> >
+          (function, MakeTuple(p1, p2));
+  return MutantFunctor<R, Tuple5<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> >
+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 =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4, A5),
+                               Tuple2<P1, P2>, Tuple5<A1, A2, A3, A4, A5> >
+          (obj, method, MakeTuple(p1, p2));
+  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif  // OS_WIN
+
+// 2 - 6
+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> >
+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 =
+      new Mutant<R, T, R (U::*)(X1, X2, A1, A2, A3, A4, A5, A6),
+                 Tuple2<P1, P2>, Tuple6<A1, A2, A3, A4, A5, A6> >
+          (obj, method, MakeTuple(p1, p2));
+  return MutantFunctor<R, Tuple6<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> >
+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 =
+      new MutantFunction<R, R (*)(X1, X2, A1, A2, A3, A4, A5, A6),
+                         Tuple2<P1, P2>, Tuple6<A1, A2, A3, A4, A5, A6> >
+          (function, MakeTuple(p1, p2));
+  return MutantFunctor<R, Tuple6<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> >
+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 =
+      new MutantLateObjectBind<R, T, R (U::*)(X1, X2, A1, A2, A3, A4, A5, A6),
+                               Tuple2<P1, P2>, Tuple6<A1, A2, A3, A4, A5, A6> >
+          (obj, method, MakeTuple(p1, p2));
+  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2));
+  return MutantFunctor<R, Tuple6<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> >
+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 =
+      new MutantFunction<R, R (__stdcall *)(X1, X2, A1, A2, A3, A4, A5, A6),
+                         Tuple2<P1, P2>, Tuple6<A1, A2, A3, A4, A5, A6> >
+          (function, MakeTuple(p1, p2));
+  return MutantFunctor<R, Tuple6<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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2));
+  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif  // OS_WIN
+
 // 3 - 0
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename X1, typename X2, typename X3>
@@ -2084,6 +2957,174 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4),
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
+// 3 - 5
+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> >
+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 =
+      new Mutant<R, T, R (U::*)(X1, X2, X3, A1, A2, A3, A4, A5),
+                 Tuple3<P1, P2, P3>, Tuple5<A1, A2, A3, A4, A5> >
+          (obj, method, MakeTuple(p1, p2, p3));
+  return MutantFunctor<R, Tuple5<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> >
+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 =
+      new MutantFunction<R, R (*)(X1, X2, X3, A1, A2, A3, A4, A5),
+                         Tuple3<P1, P2, P3>, Tuple5<A1, A2, A3, A4, A5> >
+          (function, MakeTuple(p1, p2, p3));
+  return MutantFunctor<R, Tuple5<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> >
+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 =
+      new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, A1, A2, A3, A4, A5),
+                               Tuple3<P1, P2, P3>, Tuple5<A1, A2, A3, A4, A5> >
+          (obj, method, MakeTuple(p1, p2, p3));
+  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3));
+  return MutantFunctor<R, Tuple5<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> >
+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 =
+      new MutantFunction<R, R (__stdcall *)(X1, X2, X3, A1, A2, A3, A4, A5),
+                         Tuple3<P1, P2, P3>, Tuple5<A1, A2, A3, A4, A5> >
+          (function, MakeTuple(p1, p2, p3));
+  return MutantFunctor<R, Tuple5<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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3));
+  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif  // OS_WIN
+
+// 3 - 6
+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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3));
+  return MutantFunctor<R, Tuple6<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> >
+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 =
+      new MutantFunction<R, R (*)(X1, X2, X3, A1, A2, A3, A4, A5, A6),
+                         Tuple3<P1, P2, P3>, Tuple6<A1, A2, A3, A4, A5, A6> >
+          (function, MakeTuple(p1, p2, p3));
+  return MutantFunctor<R, Tuple6<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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3));
+  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3));
+  return MutantFunctor<R, Tuple6<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> >
+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 =
+      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> >
+          (function, MakeTuple(p1, p2, p3));
+  return MutantFunctor<R, Tuple6<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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3));
+  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif  // OS_WIN
+
 // 4 - 0
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename X1, typename X2, typename X3,
@@ -2500,6 +3541,1455 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4),
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
+// 4 - 5
+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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4));
+  return MutantFunctor<R, Tuple5<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> >
+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 =
+      new MutantFunction<R, R (*)(X1, X2, X3, X4, A1, A2, A3, A4, A5),
+                         Tuple4<P1, P2, P3, P4>, Tuple5<A1, A2, A3, A4, A5> >
+          (function, MakeTuple(p1, p2, p3, p4));
+  return MutantFunctor<R, Tuple5<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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4));
+  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4));
+  return MutantFunctor<R, Tuple5<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> >
+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 =
+      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> >
+          (function, MakeTuple(p1, p2, p3, p4));
+  return MutantFunctor<R, Tuple5<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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4));
+  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif  // OS_WIN
+
+// 4 - 6
+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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4));
+  return MutantFunctor<R, Tuple6<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> >
+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 =
+      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> >
+          (function, MakeTuple(p1, p2, p3, p4));
+  return MutantFunctor<R, Tuple6<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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4));
+  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4));
+  return MutantFunctor<R, Tuple6<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> >
+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 =
+      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> >
+          (function, MakeTuple(p1, p2, p3, p4));
+  return MutantFunctor<R, Tuple6<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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4));
+  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif  // OS_WIN
+
+// 5 - 0
+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>
+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 =
+      new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5),
+                 Tuple5<P1, P2, P3, P4, P5>, Tuple0>
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple0>(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>
+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 =
+      new MutantFunction<R, R (*)(X1, X2, X3, X4, X5),
+                         Tuple5<P1, P2, P3, P4, P5>, Tuple0>
+          (function, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple0>(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>
+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 =
+      new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5),
+                               Tuple5<P1, P2, P3, P4, P5>, Tuple0>
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple0>(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+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>
+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 =
+      new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5),
+                 Tuple5<P1, P2, P3, P4, P5>, Tuple0>
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple0>(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>
+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 =
+      new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5),
+                         Tuple5<P1, P2, P3, P4, P5>, Tuple0>
+          (function, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple0>(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>
+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 =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5),
+                               Tuple5<P1, P2, P3, P4, P5>, Tuple0>
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple0>(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif  // OS_WIN
+
+// 5 - 1
+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> >
+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 =
+      new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1),
+                 Tuple5<P1, P2, P3, P4, P5>, Tuple1<A1> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple1<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> >
+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 =
+      new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1),
+                         Tuple5<P1, P2, P3, P4, P5>, Tuple1<A1> >
+          (function, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple1<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> >
+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 =
+      new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1),
+                               Tuple5<P1, P2, P3, P4, P5>, Tuple1<A1> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple1<A1> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+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> >
+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 =
+      new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1),
+                 Tuple5<P1, P2, P3, P4, P5>, Tuple1<A1> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple1<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> >
+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 =
+      new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1),
+                         Tuple5<P1, P2, P3, P4, P5>, Tuple1<A1> >
+          (function, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple1<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> >
+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 =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1),
+                               Tuple5<P1, P2, P3, P4, P5>, Tuple1<A1> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple1<A1> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif  // OS_WIN
+
+// 5 - 2
+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> >
+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 =
+      new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2),
+                 Tuple5<P1, P2, P3, P4, P5>, Tuple2<A1, A2> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple2<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> >
+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 =
+      new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1, A2),
+                         Tuple5<P1, P2, P3, P4, P5>, Tuple2<A1, A2> >
+          (function, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple2<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> >
+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 =
+      new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2),
+                               Tuple5<P1, P2, P3, P4, P5>, Tuple2<A1, A2> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+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> >
+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 =
+      new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2),
+                 Tuple5<P1, P2, P3, P4, P5>, Tuple2<A1, A2> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple2<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> >
+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 =
+      new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1, A2),
+                         Tuple5<P1, P2, P3, P4, P5>, Tuple2<A1, A2> >
+          (function, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple2<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> >
+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 =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, A1, A2),
+                               Tuple5<P1, P2, P3, P4, P5>, Tuple2<A1, A2> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif  // OS_WIN
+
+// 5 - 3
+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> >
+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 =
+      new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3),
+                 Tuple5<P1, P2, P3, P4, P5>, Tuple3<A1, A2, A3> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple3<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> >
+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 =
+      new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1, A2, A3),
+                         Tuple5<P1, P2, P3, P4, P5>, Tuple3<A1, A2, A3> >
+          (function, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple3<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> >
+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 =
+      new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, A1, A2, A3),
+                               Tuple5<P1, P2, P3, P4, P5>, Tuple3<A1, A2, A3> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple3<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> >
+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 =
+      new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, A1, A2, A3),
+                         Tuple5<P1, P2, P3, P4, P5>, Tuple3<A1, A2, A3> >
+          (function, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple3<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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif  // OS_WIN
+
+// 5 - 4
+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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple4<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> >
+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 =
+      new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, A1, A2, A3, A4),
+                         Tuple5<P1, P2, P3, P4, P5>, Tuple4<A1, A2, A3, A4> >
+          (function, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple4<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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple4<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> >
+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 =
+      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> >
+          (function, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple4<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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif  // OS_WIN
+
+// 5 - 5
+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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple5<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> >
+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 =
+      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> >
+          (function, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple5<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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple5<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> >
+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 =
+      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> >
+          (function, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple5<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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif  // OS_WIN
+
+// 5 - 6
+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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple6<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> >
+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 =
+      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> >
+          (function, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple6<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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple6<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> >
+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 =
+      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> >
+          (function, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple6<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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5));
+  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif  // OS_WIN
+
+// 6 - 0
+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>
+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 =
+      new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6),
+                 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple0>
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple0>(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>
+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 =
+      new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6),
+                         Tuple6<P1, P2, P3, P4, P5, P6>, Tuple0>
+          (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple0>(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>
+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 =
+      new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6),
+                               Tuple6<P1, P2, P3, P4, P5, P6>, Tuple0>
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple0>(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+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>
+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 =
+      new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6),
+                 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple0>
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple0>(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>
+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 =
+      new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6),
+                         Tuple6<P1, P2, P3, P4, P5, P6>, Tuple0>
+          (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple0>(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>
+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 =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6),
+                               Tuple6<P1, P2, P3, P4, P5, P6>, Tuple0>
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple0>(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif  // OS_WIN
+
+// 6 - 1
+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> >
+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 =
+      new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1),
+                 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple1<A1> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple1<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> >
+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 =
+      new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1),
+                         Tuple6<P1, P2, P3, P4, P5, P6>, Tuple1<A1> >
+          (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple1<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> >
+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 =
+      new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1),
+                               Tuple6<P1, P2, P3, P4, P5, P6>, Tuple1<A1> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple1<A1> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+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> >
+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 =
+      new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1),
+                 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple1<A1> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple1<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> >
+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 =
+      new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1),
+                         Tuple6<P1, P2, P3, P4, P5, P6>, Tuple1<A1> >
+          (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple1<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> >
+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 =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, X5, X6, A1),
+                               Tuple6<P1, P2, P3, P4, P5, P6>, Tuple1<A1> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple1<A1> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif  // OS_WIN
+
+// 6 - 2
+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> >
+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 =
+      new Mutant<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2),
+                 Tuple6<P1, P2, P3, P4, P5, P6>, Tuple2<A1, A2> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple2<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> >
+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 =
+      new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1, A2),
+                         Tuple6<P1, P2, P3, P4, P5, P6>, Tuple2<A1, A2> >
+          (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple2<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> >
+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 =
+      new MutantLateObjectBind<R, T, R (U::*)(X1, X2, X3, X4, X5, X6, A1, A2),
+                               Tuple6<P1, P2, P3, P4, P5, P6>, Tuple2<A1, A2> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple2<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> >
+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 =
+      new MutantFunction<R, R (__stdcall *)(X1, X2, X3, X4, X5, X6, A1, A2),
+                         Tuple6<P1, P2, P3, P4, P5, P6>, Tuple2<A1, A2> >
+          (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple2<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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif  // OS_WIN
+
+// 6 - 3
+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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple3<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> >
+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 =
+      new MutantFunction<R, R (*)(X1, X2, X3, X4, X5, X6, A1, A2, A3),
+                         Tuple6<P1, P2, P3, P4, P5, P6>, Tuple3<A1, A2, A3> >
+          (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple3<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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple3<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> >
+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 =
+      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> >
+          (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple3<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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif  // OS_WIN
+
+// 6 - 4
+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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple4<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> >
+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 =
+      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> >
+          (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple4<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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple4<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> >
+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 =
+      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> >
+          (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple4<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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif  // OS_WIN
+
+// 6 - 5
+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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple5<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> >
+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 =
+      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> >
+          (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple5<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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple5<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> >
+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 =
+      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> >
+          (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple5<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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif  // OS_WIN
+
+// 6 - 6
+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 A6,
+          typename X1, typename X2, typename X3, typename X4, typename X5,
+          typename X6>
+inline MutantFunctor<R, Tuple6<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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple6<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> >
+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 =
+      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> >
+          (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple6<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 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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+
+#if defined (OS_WIN)
+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 A6,
+          typename X1, typename X2, typename X3, typename X4, typename X5,
+          typename X6>
+inline MutantFunctor<R, Tuple6<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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple6<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> >
+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 =
+      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> >
+          (function, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple6<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 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> >
+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 =
+      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> >
+          (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6));
+  return MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#endif  // OS_WIN
+
 }  // namespace testing
 
 #endif  // TESTING_GMOCK_MUTANT_H_