Late object binding for stdcall.

testing/gmock_mutant.h

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file automatically generated by testing/generate_gmock_mutant.py.
 // DO NOT EDIT.
 
 #ifndef TESTING_GMOCK_MUTANT_H_
 #define TESTING_GMOCK_MUTANT_H_
 
@@ skipping 632 matching lines @@
 #if defined (OS_WIN)
 template <typename R, typename T, typename U>
 inline MutantFunctor<R, Tuple0>
 CreateFunctor(T* obj, R (__stdcall U::*method)()) {
   MutantRunner<R, Tuple0>* t =
       new Mutant<R, T, R (__stdcall U::*)(),
                  Tuple0, Tuple0>
           (obj, method, MakeTuple());
   return MutantFunctor<R, Tuple0>(t);
 }
+#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+template <typename R, typename T, typename U>
+inline MutantFunctor<R, Tuple0>
+CreateFunctor(T** obj, R (__stdcall U::*method)()) {
+  MutantRunner<R, Tuple0>* t =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(),
+                               Tuple0, Tuple0>
+          (obj, method, MakeTuple());
+  return MutantFunctor<R, Tuple0>(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
 // 0 - 1
 template <typename R, typename T, typename U, typename A1>
 inline MutantFunctor<R, Tuple1<A1> >
 CreateFunctor(T* obj, R (U::*method)(A1)) {
   MutantRunner<R, Tuple1<A1> >* t =
       new Mutant<R, T, R (U::*)(A1),
                  Tuple0, Tuple1<A1> >
           (obj, method, MakeTuple());
@@ skipping 25 matching lines @@
 #if defined (OS_WIN)
 template <typename R, typename T, typename U, typename A1>
 inline MutantFunctor<R, Tuple1<A1> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(A1)) {
   MutantRunner<R, Tuple1<A1> >* t =
       new Mutant<R, T, R (__stdcall U::*)(A1),
                  Tuple0, Tuple1<A1> >
           (obj, method, MakeTuple());
   return MutantFunctor<R, Tuple1<A1> >(t);
 }
+#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+template <typename R, typename T, typename U, typename A1>
+inline MutantFunctor<R, Tuple1<A1> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(A1)) {
+  MutantRunner<R, Tuple1<A1> >* t =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1),
+                               Tuple0, Tuple1<A1> >
+          (obj, method, MakeTuple());
+  return MutantFunctor<R, Tuple1<A1> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
 // 0 - 2
 template <typename R, typename T, typename U, typename A1, typename A2>
 inline MutantFunctor<R, Tuple2<A1, A2> >
 CreateFunctor(T* obj, R (U::*method)(A1, A2)) {
   MutantRunner<R, Tuple2<A1, A2> >* t =
       new Mutant<R, T, R (U::*)(A1, A2),
                  Tuple0, Tuple2<A1, A2> >
           (obj, method, MakeTuple());
@@ skipping 25 matching lines @@
 #if defined (OS_WIN)
 template <typename R, typename T, typename U, typename A1, typename A2>
 inline MutantFunctor<R, Tuple2<A1, A2> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2)) {
   MutantRunner<R, Tuple2<A1, A2> >* t =
       new Mutant<R, T, R (__stdcall U::*)(A1, A2),
                  Tuple0, Tuple2<A1, A2> >
           (obj, method, MakeTuple());
   return MutantFunctor<R, Tuple2<A1, A2> >(t);
 }
+#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+template <typename R, typename T, typename U, typename A1, typename A2>
+inline MutantFunctor<R, Tuple2<A1, A2> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2)) {
+  MutantRunner<R, Tuple2<A1, A2> >* t =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1, A2),
+                               Tuple0, Tuple2<A1, A2> >
+          (obj, method, MakeTuple());
+  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
 // 0 - 3
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3>
 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
 CreateFunctor(T* obj, R (U::*method)(A1, A2, A3)) {
   MutantRunner<R, Tuple3<A1, A2, A3> >* t =
       new Mutant<R, T, R (U::*)(A1, A2, A3),
                  Tuple0, Tuple3<A1, A2, A3> >
@@ skipping 28 matching lines @@
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3>
 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3)) {
   MutantRunner<R, Tuple3<A1, A2, A3> >* t =
       new Mutant<R, T, R (__stdcall U::*)(A1, A2, A3),
                  Tuple0, Tuple3<A1, A2, A3> >
           (obj, method, MakeTuple());
   return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
 }
+#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+template <typename R, typename T, typename U, typename A1, typename A2,
+          typename A3>
+inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3)) {
+  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1, A2, A3),
+                               Tuple0, Tuple3<A1, A2, A3> >
+          (obj, method, MakeTuple());
+  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
 // 0 - 4
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3, typename A4>
 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
 CreateFunctor(T* obj, R (U::*method)(A1, A2, A3, A4)) {
   MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
       new Mutant<R, T, R (U::*)(A1, A2, A3, A4),
                  Tuple0, Tuple4<A1, A2, A3, A4> >
@@ skipping 28 matching lines @@
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3, typename A4>
 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3, A4)) {
   MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
       new Mutant<R, T, R (__stdcall U::*)(A1, A2, A3, A4),
                  Tuple0, Tuple4<A1, A2, A3, A4> >
           (obj, method, MakeTuple());
   return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
 }
+#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+template <typename R, typename T, typename U, typename A1, typename A2,
+          typename A3, typename A4>
+inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4)) {
+  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(A1, A2, A3, A4),
+                               Tuple0, Tuple4<A1, A2, A3, A4> >
+          (obj, method, MakeTuple());
+  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(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>
 CreateFunctor(T* obj, R (U::*method)(X1), const P1& p1) {
   MutantRunner<R, Tuple0>* t =
       new Mutant<R, T, R (U::*)(X1),
                  Tuple1<P1>, Tuple0>
           (obj, method, MakeTuple(p1));
@@ skipping 25 matching lines @@
 #if defined (OS_WIN)
 template <typename R, typename T, typename U, typename P1, typename X1>
 inline MutantFunctor<R, Tuple0>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1), const P1& p1) {
   MutantRunner<R, Tuple0>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1),
                  Tuple1<P1>, Tuple0>
           (obj, method, MakeTuple(p1));
   return MutantFunctor<R, Tuple0>(t);
 }
+#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+template <typename R, typename T, typename U, typename P1, typename X1>
+inline MutantFunctor<R, Tuple0>
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1), const P1& p1) {
+  MutantRunner<R, Tuple0>* t =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1),
+                               Tuple1<P1>, Tuple0>
+          (obj, method, MakeTuple(p1));
+  return MutantFunctor<R, Tuple0>(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
 // 1 - 1
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename X1>
 inline MutantFunctor<R, Tuple1<A1> >
 CreateFunctor(T* obj, R (U::*method)(X1, A1), const P1& p1) {
   MutantRunner<R, Tuple1<A1> >* t =
       new Mutant<R, T, R (U::*)(X1, A1),
                  Tuple1<P1>, Tuple1<A1> >
@@ skipping 28 matching lines @@
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename X1>
 inline MutantFunctor<R, Tuple1<A1> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1), const P1& p1) {
   MutantRunner<R, Tuple1<A1> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, A1),
                  Tuple1<P1>, Tuple1<A1> >
           (obj, method, MakeTuple(p1));
   return MutantFunctor<R, Tuple1<A1> >(t);
 }
+#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+template <typename R, typename T, typename U, typename P1, typename A1,
+          typename X1>
+inline MutantFunctor<R, Tuple1<A1> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1), const P1& p1) {
+  MutantRunner<R, Tuple1<A1> >* t =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1),
+                               Tuple1<P1>, Tuple1<A1> >
+          (obj, method, MakeTuple(p1));
+  return MutantFunctor<R, Tuple1<A1> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
 // 1 - 2
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename X1>
 inline MutantFunctor<R, Tuple2<A1, A2> >
 CreateFunctor(T* obj, R (U::*method)(X1, A1, A2), const P1& p1) {
   MutantRunner<R, Tuple2<A1, A2> >* t =
       new Mutant<R, T, R (U::*)(X1, A1, A2),
                  Tuple1<P1>, Tuple2<A1, A2> >
@@ skipping 28 matching lines @@
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename X1>
 inline MutantFunctor<R, Tuple2<A1, A2> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2), const P1& p1) {
   MutantRunner<R, Tuple2<A1, A2> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, A1, A2),
                  Tuple1<P1>, Tuple2<A1, A2> >
           (obj, method, MakeTuple(p1));
   return MutantFunctor<R, Tuple2<A1, A2> >(t);
 }
+#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+template <typename R, typename T, typename U, typename P1, typename A1,
+          typename A2, typename X1>
+inline MutantFunctor<R, Tuple2<A1, A2> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2), const P1& p1) {
+  MutantRunner<R, Tuple2<A1, A2> >* t =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1, A2),
+                               Tuple1<P1>, Tuple2<A1, A2> >
+          (obj, method, MakeTuple(p1));
+  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
 // 1 - 3
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename A3, typename X1>
 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
 CreateFunctor(T* obj, R (U::*method)(X1, A1, A2, A3), const P1& p1) {
   MutantRunner<R, Tuple3<A1, A2, A3> >* t =
       new Mutant<R, T, R (U::*)(X1, A1, A2, A3),
                  Tuple1<P1>, Tuple3<A1, A2, A3> >
@@ skipping 29 matching lines @@
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename A3, typename X1>
 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2, A3), const P1& p1) {
   MutantRunner<R, Tuple3<A1, A2, A3> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, A1, A2, A3),
                  Tuple1<P1>, Tuple3<A1, A2, A3> >
           (obj, method, MakeTuple(p1));
   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 A1,
+          typename A2, typename A3, typename X1>
+inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3), const P1& p1) {
+  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1, A2, A3),
+                               Tuple1<P1>, Tuple3<A1, A2, A3> >
+          (obj, method, MakeTuple(p1));
+  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
 // 1 - 4
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename A3, typename A4, typename X1>
 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
 CreateFunctor(T* obj, R (U::*method)(X1, A1, A2, A3, A4), const P1& p1) {
   MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
       new Mutant<R, T, R (U::*)(X1, A1, A2, A3, A4),
                  Tuple1<P1>, Tuple4<A1, A2, A3, A4> >
@@ skipping 30 matching lines @@
           typename A2, typename A3, typename A4, typename X1>
 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4),
     const P1& p1) {
   MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4),
                  Tuple1<P1>, Tuple4<A1, A2, A3, A4> >
           (obj, method, MakeTuple(p1));
   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 A1,
+          typename A2, typename A3, typename A4, typename X1>
+inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4),
+    const P1& p1) {
+  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, A1, A2, A3, A4),
+                               Tuple1<P1>, Tuple4<A1, A2, A3, A4> >
+          (obj, method, MakeTuple(p1));
+  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(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>
 inline MutantFunctor<R, Tuple0>
 CreateFunctor(T* obj, R (U::*method)(X1, X2), const P1& p1, const P2& p2) {
   MutantRunner<R, Tuple0>* t =
       new Mutant<R, T, R (U::*)(X1, X2),
                  Tuple2<P1, P2>, Tuple0>
@@ skipping 29 matching lines @@
           typename X1, typename X2>
 inline MutantFunctor<R, Tuple0>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2), const P1& p1,
     const P2& p2) {
   MutantRunner<R, Tuple0>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2),
                  Tuple2<P1, P2>, Tuple0>
           (obj, method, MakeTuple(p1, p2));
   return MutantFunctor<R, Tuple0>(t);
 }
+#ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+template <typename R, typename T, typename U, typename P1, typename P2,
+          typename X1, typename X2>
+inline MutantFunctor<R, Tuple0>
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2), const P1& p1,
+    const P2& p2) {
+  MutantRunner<R, Tuple0>* t =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2),
+                               Tuple2<P1, P2>, Tuple0>
+          (obj, method, MakeTuple(p1, p2));
+  return MutantFunctor<R, Tuple0>(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
 // 2 - 1
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename X1, typename X2>
 inline MutantFunctor<R, Tuple1<A1> >
 CreateFunctor(T* obj, R (U::*method)(X1, X2, A1), const P1& p1, const P2& p2) {
   MutantRunner<R, Tuple1<A1> >* t =
       new Mutant<R, T, R (U::*)(X1, X2, A1),
                  Tuple2<P1, P2>, Tuple1<A1> >
@@ skipping 30 matching lines @@
           typename A1, typename X1, typename X2>
 inline MutantFunctor<R, Tuple1<A1> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1), const P1& p1,
     const P2& p2) {
   MutantRunner<R, Tuple1<A1> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1),
                  Tuple2<P1, P2>, Tuple1<A1> >
           (obj, method, MakeTuple(p1, p2));
   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 A1, typename X1, typename X2>
+inline MutantFunctor<R, Tuple1<A1> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1), const P1& p1,
+    const P2& p2) {
+  MutantRunner<R, Tuple1<A1> >* t =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1),
+                               Tuple2<P1, P2>, Tuple1<A1> >
+          (obj, method, MakeTuple(p1, p2));
+  return MutantFunctor<R, Tuple1<A1> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
 // 2 - 2
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename X1, typename X2>
 inline MutantFunctor<R, Tuple2<A1, A2> >
 CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2), const P1& p1,
     const P2& p2) {
   MutantRunner<R, Tuple2<A1, A2> >* t =
       new Mutant<R, T, R (U::*)(X1, X2, A1, A2),
@@ skipping 32 matching lines @@
           typename A1, typename A2, typename X1, typename X2>
 inline MutantFunctor<R, Tuple2<A1, A2> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2), const P1& p1,
     const P2& p2) {
   MutantRunner<R, Tuple2<A1, A2> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1, A2),
                  Tuple2<P1, P2>, Tuple2<A1, A2> >
           (obj, method, MakeTuple(p1, p2));
   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 A1, typename A2, typename X1, typename X2>
+inline MutantFunctor<R, Tuple2<A1, A2> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2), const P1& p1,
+    const P2& p2) {
+  MutantRunner<R, Tuple2<A1, A2> >* t =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1, A2),
+                               Tuple2<P1, P2>, Tuple2<A1, A2> >
+          (obj, method, MakeTuple(p1, p2));
+  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
 // 2 - 3
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename A3, typename X1, typename X2>
 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
 CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2, A3), const P1& p1,
     const P2& p2) {
   MutantRunner<R, Tuple3<A1, A2, A3> >* t =
       new Mutant<R, T, R (U::*)(X1, X2, A1, A2, A3),
@@ skipping 32 matching lines @@
           typename A1, typename A2, typename A3, typename X1, typename X2>
 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3),
     const P1& p1, const P2& p2) {
   MutantRunner<R, Tuple3<A1, A2, A3> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3),
                  Tuple2<P1, P2>, Tuple3<A1, A2, A3> >
           (obj, method, MakeTuple(p1, p2));
   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 A1, typename A2, typename A3, typename X1, typename X2>
+inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3),
+    const P1& p1, const P2& p2) {
+  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3),
+                               Tuple2<P1, P2>, Tuple3<A1, A2, A3> >
+          (obj, method, MakeTuple(p1, p2));
+  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
 // 2 - 4
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename A3, typename A4, typename X1,
           typename X2>
 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
 CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2, A3, A4), const P1& p1,
     const P2& p2) {
   MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
@@ skipping 36 matching lines @@
           typename X2>
 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4),
     const P1& p1, const P2& p2) {
   MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4),
                  Tuple2<P1, P2>, Tuple4<A1, A2, A3, A4> >
           (obj, method, MakeTuple(p1, p2));
   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 A1, typename A2, typename A3, typename A4, typename X1,
+          typename X2>
+inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4),
+    const P1& p1, const P2& p2) {
+  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, A1, A2, A3, A4),
+                               Tuple2<P1, P2>, Tuple4<A1, A2, A3, A4> >
+          (obj, method, MakeTuple(p1, p2));
+  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(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>
 inline MutantFunctor<R, Tuple0>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3), const P1& p1, const P2& p2,
     const P3& p3) {
   MutantRunner<R, Tuple0>* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3),
@@ skipping 33 matching lines @@
           typename P3, typename X1, typename X2, typename X3>
 inline MutantFunctor<R, Tuple0>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3), const P1& p1,
     const P2& p2, const P3& p3) {
   MutantRunner<R, Tuple0>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3),
                  Tuple3<P1, P2, P3>, Tuple0>
           (obj, method, MakeTuple(p1, p2, p3));
   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 X1, typename X2, typename X3>
+inline MutantFunctor<R, Tuple0>
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3), const P1& p1,
+    const P2& p2, const P3& p3) {
+  MutantRunner<R, Tuple0>* t =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3),
+                               Tuple3<P1, P2, P3>, Tuple0>
+          (obj, method, MakeTuple(p1, p2, p3));
+  return MutantFunctor<R, Tuple0>(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
 // 3 - 1
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename X1, typename X2, typename X3>
 inline MutantFunctor<R, Tuple1<A1> >
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1), const P1& p1,
     const P2& p2, const P3& p3) {
   MutantRunner<R, Tuple1<A1> >* t =
       new Mutant<R, T, R (U::*)(X1, X2, X3, A1),
@@ skipping 33 matching lines @@
           typename P3, typename A1, typename X1, typename X2, typename X3>
 inline MutantFunctor<R, Tuple1<A1> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1), const P1& p1,
     const P2& p2, const P3& p3) {
   MutantRunner<R, Tuple1<A1> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1),
                  Tuple3<P1, P2, P3>, Tuple1<A1> >
           (obj, method, MakeTuple(p1, p2, p3));
   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 A1, typename X1, typename X2, typename X3>
+inline MutantFunctor<R, Tuple1<A1> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1), const P1& p1,
+    const P2& p2, const P3& p3) {
+  MutantRunner<R, Tuple1<A1> >* t =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1),
+                               Tuple3<P1, P2, P3>, Tuple1<A1> >
+          (obj, method, MakeTuple(p1, p2, p3));
+  return MutantFunctor<R, Tuple1<A1> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
 // 3 - 2
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename A2, typename X1, typename X2,
           typename X3>
 inline MutantFunctor<R, Tuple2<A1, A2> >
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2), const P1& p1,
     const P2& p2, const P3& p3) {
   MutantRunner<R, Tuple2<A1, A2> >* t =
@@ skipping 36 matching lines @@
           typename X3>
 inline MutantFunctor<R, Tuple2<A1, A2> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2),
     const P1& p1, const P2& p2, const P3& p3) {
   MutantRunner<R, Tuple2<A1, A2> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2),
                  Tuple3<P1, P2, P3>, Tuple2<A1, A2> >
           (obj, method, MakeTuple(p1, p2, p3));
   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 A1, typename A2, typename X1, typename X2,
+          typename X3>
+inline MutantFunctor<R, Tuple2<A1, A2> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2),
+    const P1& p1, const P2& p2, const P3& p3) {
+  MutantRunner<R, Tuple2<A1, A2> >* t =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2),
+                               Tuple3<P1, P2, P3>, Tuple2<A1, A2> >
+          (obj, method, MakeTuple(p1, p2, p3));
+  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
 // 3 - 3
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename A2, typename A3, typename X1,
           typename X2, typename X3>
 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2, A3), const P1& p1,
     const P2& p2, const P3& p3) {
   MutantRunner<R, Tuple3<A1, A2, A3> >* t =
@@ skipping 36 matching lines @@
           typename X2, typename X3>
 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3),
     const P1& p1, const P2& p2, const P3& p3) {
   MutantRunner<R, Tuple3<A1, A2, A3> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3),
                  Tuple3<P1, P2, P3>, Tuple3<A1, A2, A3> >
           (obj, method, MakeTuple(p1, p2, p3));
   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 A1, typename A2, typename A3, typename X1,
+          typename X2, typename X3>
+inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3),
+    const P1& p1, const P2& p2, const P3& p3) {
+  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3),
+                               Tuple3<P1, P2, P3>, Tuple3<A1, A2, A3> >
+          (obj, method, MakeTuple(p1, p2, p3));
+  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
 // 3 - 4
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename A2, typename A3, typename A4,
           typename X1, typename X2, typename X3>
 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4), const P1& p1,
     const P2& p2, const P3& p3) {
   MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
@@ skipping 37 matching lines @@
           typename X1, typename X2, typename X3>
 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4),
     const P1& p1, const P2& p2, const P3& p3) {
   MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3, A4),
                  Tuple3<P1, P2, P3>, Tuple4<A1, A2, A3, A4> >
           (obj, method, MakeTuple(p1, p2, p3));
   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 A1, typename A2, typename A3, typename A4,
+          typename X1, typename X2, typename X3>
+inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4),
+    const P1& p1, const P2& p2, const P3& p3) {
+  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2, A3, A4),
+                               Tuple3<P1, P2, P3>, Tuple4<A1, A2, A3, A4> >
+          (obj, method, MakeTuple(p1, p2, p3));
+  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(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,
           typename X4>
 inline MutantFunctor<R, Tuple0>
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4) {
   MutantRunner<R, Tuple0>* t =
@@ skipping 36 matching lines @@
           typename X4>
 inline MutantFunctor<R, Tuple0>
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4) {
   MutantRunner<R, Tuple0>* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4),
                  Tuple4<P1, P2, P3, P4>, Tuple0>
           (obj, method, MakeTuple(p1, p2, p3, p4));
   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 X1, typename X2, typename X3,
+          typename X4>
+inline MutantFunctor<R, Tuple0>
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4), const P1& p1,
+    const P2& p2, const P3& p3, const P4& p4) {
+  MutantRunner<R, Tuple0>* t =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4),
+                               Tuple4<P1, P2, P3, P4>, Tuple0>
+          (obj, method, MakeTuple(p1, p2, p3, p4));
+  return MutantFunctor<R, Tuple0>(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
 // 4 - 1
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename X1, typename X2,
           typename X3, typename X4>
 inline MutantFunctor<R, Tuple1<A1> >
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4) {
   MutantRunner<R, Tuple1<A1> >* t =
@@ skipping 36 matching lines @@
           typename X3, typename X4>
 inline MutantFunctor<R, Tuple1<A1> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
   MutantRunner<R, Tuple1<A1> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1),
                  Tuple4<P1, P2, P3, P4>, Tuple1<A1> >
           (obj, method, MakeTuple(p1, p2, p3, p4));
   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 A1, typename X1, typename X2,
+          typename X3, typename X4>
+inline MutantFunctor<R, Tuple1<A1> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1),
+    const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+  MutantRunner<R, Tuple1<A1> >* t =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1),
+                               Tuple4<P1, P2, P3, P4>, Tuple1<A1> >
+          (obj, method, MakeTuple(p1, p2, p3, p4));
+  return MutantFunctor<R, Tuple1<A1> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
 // 4 - 2
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename A2, typename X1,
           typename X2, typename X3, typename X4>
 inline MutantFunctor<R, Tuple2<A1, A2> >
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4) {
   MutantRunner<R, Tuple2<A1, A2> >* t =
@@ skipping 37 matching lines @@
           typename X2, typename X3, typename X4>
 inline MutantFunctor<R, Tuple2<A1, A2> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
   MutantRunner<R, Tuple2<A1, A2> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2),
                  Tuple4<P1, P2, P3, P4>, Tuple2<A1, A2> >
           (obj, method, MakeTuple(p1, p2, p3, p4));
   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 A1, typename A2, typename X1,
+          typename X2, typename X3, typename X4>
+inline MutantFunctor<R, Tuple2<A1, A2> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2),
+    const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+  MutantRunner<R, Tuple2<A1, A2> >* t =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2),
+                               Tuple4<P1, P2, P3, P4>, Tuple2<A1, A2> >
+          (obj, method, MakeTuple(p1, p2, p3, p4));
+  return MutantFunctor<R, Tuple2<A1, A2> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
 // 4 - 3
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename A2, typename A3,
           typename X1, typename X2, typename X3, typename X4>
 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3), const P1& p1,
     const P2& p2, const P3& p3, const P4& p4) {
   MutantRunner<R, Tuple3<A1, A2, A3> >* t =
@@ skipping 37 matching lines @@
           typename X1, typename X2, typename X3, typename X4>
 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
   MutantRunner<R, Tuple3<A1, A2, A3> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3),
                  Tuple4<P1, P2, P3, P4>, Tuple3<A1, A2, A3> >
           (obj, method, MakeTuple(p1, p2, p3, p4));
   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 A1, typename A2, typename A3,
+          typename X1, typename X2, typename X3, typename X4>
+inline MutantFunctor<R, Tuple3<A1, A2, A3> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3),
+    const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+  MutantRunner<R, Tuple3<A1, A2, A3> >* t =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3),
+                               Tuple4<P1, P2, P3, P4>, Tuple3<A1, A2, A3> >
+          (obj, method, MakeTuple(p1, p2, p3, p4));
+  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
 // 4 - 4
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename P4, typename A1, typename A2, typename A3,
           typename A4, typename X1, typename X2, typename X3, typename X4>
 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
 CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
   MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
@@ skipping 37 matching lines @@
           typename A4, typename X1, typename X2, typename X3, typename X4>
 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
 CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4),
     const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
   MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
       new Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4),
                  Tuple4<P1, P2, P3, P4>, Tuple4<A1, A2, A3, A4> >
           (obj, method, MakeTuple(p1, p2, p3, p4));
   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 A1, typename A2, typename A3,
+          typename A4, typename X1, typename X2, typename X3, typename X4>
+inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
+CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4),
+    const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
+  MutantRunner<R, Tuple4<A1, A2, A3, A4> >* t =
+      new MutantLateObjectBind<R, T, R (__stdcall U::*)(X1, X2, X3, X4, A1, A2, A3, A4),
+                               Tuple4<P1, P2, P3, P4>, Tuple4<A1, A2, A3, A4> >
+          (obj, method, MakeTuple(p1, p2, p3, p4));
+  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
+}
+#endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #endif  // OS_WIN
 
 }  // namespace testing
 
 #endif  // TESTING_GMOCK_MUTANT_H_