Exclude duplicate gmock_mutant functor templates in WIN64

testing/gmock_mutant.h

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2013 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_
 
 // The intention of this file is to make possible using GMock actions in
@@ skipping 1029 matching lines @@
 inline MutantFunctor<R, Tuple0>
 CreateFunctor(T** obj, R (U::*method)()) {
   MutantRunner<R, Tuple0>* t =
       new MutantLateObjectBind<R, T, R (U::*)(),
                                Tuple0, Tuple0>
           (obj, method, MakeTuple());
   return MutantFunctor<R, Tuple0>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
-#if defined (OS_WIN)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 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);
 }
 
@@ skipping 10 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 0 - 1
 template <typename R, typename T, typename U, typename A1>
 inline MutantFunctor<R, Tuple1<A1> >
 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());
   return MutantFunctor<R, Tuple1<A1> >(t);
@@ skipping 14 matching lines @@
 inline MutantFunctor<R, Tuple1<A1> >
 CreateFunctor(T** obj, R (U::*method)(A1)) {
   MutantRunner<R, Tuple1<A1> >* t =
       new MutantLateObjectBind<R, T, R (U::*)(A1),
                                Tuple0, Tuple1<A1> >
           (obj, method, MakeTuple());
   return MutantFunctor<R, Tuple1<A1> >(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
-#if defined (OS_WIN)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 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);
 }
 
@@ skipping 10 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 0 - 2
 template <typename R, typename T, typename U, typename A1, typename A2>
 inline MutantFunctor<R, Tuple2<A1, A2> >
 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());
   return MutantFunctor<R, Tuple2<A1, A2> >(t);
@@ skipping 14 matching lines @@
 inline MutantFunctor<R, Tuple2<A1, A2> >
 CreateFunctor(T** obj, R (U::*method)(A1, A2)) {
   MutantRunner<R, Tuple2<A1, A2> >* t =
       new MutantLateObjectBind<R, T, R (U::*)(A1, A2),
                                Tuple0, Tuple2<A1, A2> >
           (obj, method, MakeTuple());
   return MutantFunctor<R, Tuple2<A1, A2> >(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
-#if defined (OS_WIN)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename A1, typename A2>
 inline MutantFunctor<R, Tuple2<A1, A2> >
 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);
 }
 
@@ skipping 10 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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> >
           (obj, method, MakeTuple());
@@ skipping 16 matching lines @@
 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
 CreateFunctor(T** obj, R (U::*method)(A1, A2, A3)) {
   MutantRunner<R, Tuple3<A1, A2, A3> >* t =
       new MutantLateObjectBind<R, T, R (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
 
-#if defined (OS_WIN)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3>
 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
 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);
 }
@@ skipping 12 matching lines @@
           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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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> >
           (obj, method, MakeTuple());
@@ skipping 16 matching lines @@
 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 MutantLateObjectBind<R, T, R (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
 
-#if defined (OS_WIN)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3, typename A4>
 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
 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);
 }
@@ skipping 12 matching lines @@
           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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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());
@@ skipping 17 matching lines @@
 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)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3, typename A4, typename A5>
 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
 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);
 }
@@ skipping 13 matching lines @@
           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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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());
@@ skipping 17 matching lines @@
 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)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename A1, typename A2,
           typename A3, typename A4, typename A5, typename A6>
 inline MutantFunctor<R, Tuple6<A1, A2, A3, A4, A5, A6> >
 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);
 }
@@ skipping 13 matching lines @@
           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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 1 - 0
 template <typename R, typename T, typename U, typename P1, typename X1>
 inline MutantFunctor<R, Tuple0>
 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));
   return MutantFunctor<R, Tuple0>(t);
@@ skipping 14 matching lines @@
 inline MutantFunctor<R, Tuple0>
 CreateFunctor(T** obj, R (U::*method)(X1), const P1& p1) {
   MutantRunner<R, Tuple0>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1),
                                Tuple1<P1>, Tuple0>
           (obj, method, MakeTuple(p1));
   return MutantFunctor<R, Tuple0>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
-#if defined (OS_WIN)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 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);
 }
 
@@ skipping 10 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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> >
           (obj, method, MakeTuple(p1));
@@ skipping 16 matching lines @@
 inline MutantFunctor<R, Tuple1<A1> >
 CreateFunctor(T** obj, R (U::*method)(X1, A1), const P1& p1) {
   MutantRunner<R, Tuple1<A1> >* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, A1),
                                Tuple1<P1>, Tuple1<A1> >
           (obj, method, MakeTuple(p1));
   return MutantFunctor<R, Tuple1<A1> >(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
-#if defined (OS_WIN)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename X1>
 inline MutantFunctor<R, Tuple1<A1> >
 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);
 }
@@ skipping 12 matching lines @@
           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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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> >
           (obj, method, MakeTuple(p1));
@@ skipping 16 matching lines @@
 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 MutantLateObjectBind<R, T, R (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
 
-#if defined (OS_WIN)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename X1>
 inline MutantFunctor<R, Tuple2<A1, A2> >
 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);
 }
@@ skipping 12 matching lines @@
           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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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> >
           (obj, method, MakeTuple(p1));
@@ skipping 17 matching lines @@
 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 MutantLateObjectBind<R, T, R (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
 
-#if defined (OS_WIN)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename A3, typename X1>
 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
 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);
 }
@@ skipping 13 matching lines @@
           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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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> >
           (obj, method, MakeTuple(p1));
@@ skipping 17 matching lines @@
 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 MutantLateObjectBind<R, T, R (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
 
-#if defined (OS_WIN)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename A3, typename A4, typename X1>
 inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
 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);
@@ skipping 15 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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));
@@ skipping 17 matching lines @@
 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)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename A3, typename A4, typename A5, typename X1>
 inline MutantFunctor<R, Tuple5<A1, A2, A3, A4, A5> >
 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);
@@ skipping 15 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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),
@@ skipping 21 matching lines @@
 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)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename A1,
           typename A2, typename A3, typename A4, typename A5, typename 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));
@@ skipping 18 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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>
           (obj, method, MakeTuple(p1, p2));
@@ skipping 16 matching lines @@
 inline MutantFunctor<R, Tuple0>
 CreateFunctor(T** obj, R (U::*method)(X1, X2), const P1& p1, const P2& p2) {
   MutantRunner<R, Tuple0>* t =
       new MutantLateObjectBind<R, T, R (U::*)(X1, X2),
                                Tuple2<P1, P2>, Tuple0>
           (obj, method, MakeTuple(p1, p2));
   return MutantFunctor<R, Tuple0>(t);
 }
 #endif  // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 
-#if defined (OS_WIN)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename X1, typename X2>
 inline MutantFunctor<R, Tuple0>
 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);
@@ skipping 14 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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> >
           (obj, method, MakeTuple(p1, p2));
@@ skipping 17 matching lines @@
 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 MutantLateObjectBind<R, T, R (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
 
-#if defined (OS_WIN)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename X1, typename X2>
 inline MutantFunctor<R, Tuple1<A1> >
 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);
@@ skipping 16 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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),
                  Tuple2<P1, P2>, Tuple2<A1, A2> >
@@ skipping 19 matching lines @@
 CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2), const P1& p1,
     const P2& p2) {
   MutantRunner<R, Tuple2<A1, A2> >* t =
       new MutantLateObjectBind<R, T, R (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
 
-#if defined (OS_WIN)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename X1, typename X2>
 inline MutantFunctor<R, Tuple2<A1, A2> >
 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);
@@ skipping 16 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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),
                  Tuple2<P1, P2>, Tuple3<A1, A2, A3> >
@@ skipping 19 matching lines @@
 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 MutantLateObjectBind<R, T, R (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
 
-#if defined (OS_WIN)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename A3, typename X1, typename X2>
 inline MutantFunctor<R, Tuple3<A1, A2, A3> >
 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);
@@ skipping 16 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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 =
       new Mutant<R, T, R (U::*)(X1, X2, A1, A2, A3, A4),
@@ skipping 22 matching lines @@
 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 =
       new MutantLateObjectBind<R, T, R (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
 
-#if defined (OS_WIN)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename A3, typename 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 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));
@@ skipping 18 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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),
@@ skipping 22 matching lines @@
 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)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename A3, typename 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));
@@ skipping 18 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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),
@@ skipping 23 matching lines @@
 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)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename A1, typename A2, typename A3, typename 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));
@@ skipping 19 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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),
                  Tuple3<P1, P2, P3>, Tuple0>
@@ skipping 20 matching lines @@
 CreateFunctor(T** obj, R (U::*method)(X1, X2, X3), const P1& p1, const P2& p2,
     const P3& p3) {
   MutantRunner<R, Tuple0>* t =
       new MutantLateObjectBind<R, T, R (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
 
-#if defined (OS_WIN)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename X1, typename X2, typename X3>
 inline MutantFunctor<R, Tuple0>
 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);
@@ skipping 16 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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),
                  Tuple3<P1, P2, P3>, Tuple1<A1> >
@@ skipping 20 matching lines @@
 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 MutantLateObjectBind<R, T, R (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
 
-#if defined (OS_WIN)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename X1, typename X2, typename X3>
 inline MutantFunctor<R, Tuple1<A1> >
 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);
@@ skipping 16 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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 =
       new Mutant<R, T, R (U::*)(X1, X2, X3, A1, A2),
@@ skipping 22 matching lines @@
 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 =
       new MutantLateObjectBind<R, T, R (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
 
-#if defined (OS_WIN)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename 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 Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, A1, A2),
                  Tuple3<P1, P2, P3>, Tuple2<A1, A2> >
           (obj, method, MakeTuple(p1, p2, p3));
@@ skipping 18 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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 =
       new Mutant<R, T, R (U::*)(X1, X2, X3, A1, A2, A3),
@@ skipping 22 matching lines @@
 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 =
       new MutantLateObjectBind<R, T, R (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
 
-#if defined (OS_WIN)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename 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 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));
@@ skipping 18 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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 =
       new Mutant<R, T, R (U::*)(X1, X2, X3, A1, A2, A3, A4),
@@ skipping 23 matching lines @@
 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 =
       new MutantLateObjectBind<R, T, R (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
 
-#if defined (OS_WIN)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename 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 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));
@@ skipping 19 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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),
@@ skipping 23 matching lines @@
 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)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename 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));
@@ skipping 19 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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),
@@ skipping 23 matching lines @@
 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)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 template <typename R, typename T, typename U, typename P1, typename P2,
           typename P3, typename A1, typename 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));
@@ skipping 19 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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 =
       new Mutant<R, T, R (U::*)(X1, X2, X3, X4),
@@ skipping 22 matching lines @@
 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 =
       new MutantLateObjectBind<R, T, R (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
 
-#if defined (OS_WIN)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 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 Mutant<R, T, R (__stdcall U::*)(X1, X2, X3, X4),
                  Tuple4<P1, P2, P3, P4>, Tuple0>
           (obj, method, MakeTuple(p1, p2, p3, p4));
@@ skipping 18 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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 =
       new Mutant<R, T, R (U::*)(X1, X2, X3, X4, A1),
@@ skipping 22 matching lines @@
 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 =
       new MutantLateObjectBind<R, T, R (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
 
-#if defined (OS_WIN)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 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 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));
@@ skipping 18 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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 =
       new Mutant<R, T, R (U::*)(X1, X2, X3, X4, A1, A2),
@@ skipping 23 matching lines @@
 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 =
       new MutantLateObjectBind<R, T, R (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
 
-#if defined (OS_WIN)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 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 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));
@@ skipping 19 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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 =
       new Mutant<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3),
@@ skipping 23 matching lines @@
 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 =
       new MutantLateObjectBind<R, T, R (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
 
-#if defined (OS_WIN)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 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 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));
@@ skipping 19 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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 =
       new Mutant<R, T, R (U::*)(X1, X2, X3, X4, A1, A2, A3, A4),
@@ skipping 23 matching lines @@
 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 =
       new MutantLateObjectBind<R, T, R (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
 
-#if defined (OS_WIN)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 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 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));
@@ skipping 19 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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 =
@@ skipping 25 matching lines @@
 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)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 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> >
@@ skipping 21 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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 =
@@ skipping 25 matching lines @@
 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)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 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> >
@@ skipping 21 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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),
@@ skipping 23 matching lines @@
 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)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 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));
@@ skipping 19 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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),
@@ skipping 23 matching lines @@
 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)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 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));
@@ skipping 19 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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),
@@ skipping 23 matching lines @@
 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)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 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));
@@ skipping 19 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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 =
@@ skipping 25 matching lines @@
 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)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 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> >
@@ skipping 21 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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 =
@@ skipping 25 matching lines @@
 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)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 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),
@@ skipping 23 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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 =
@@ skipping 26 matching lines @@
 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)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 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),
@@ skipping 24 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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) {
@@ skipping 28 matching lines @@
     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)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 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),
@@ skipping 25 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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),
@@ skipping 23 matching lines @@
 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)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 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>
@@ skipping 21 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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 =
@@ skipping 25 matching lines @@
 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)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 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),
@@ skipping 23 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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) {
@@ skipping 27 matching lines @@
     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)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 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),
@@ skipping 24 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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) {
@@ skipping 28 matching lines @@
     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)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 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),
@@ skipping 25 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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) {
@@ skipping 29 matching lines @@
     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)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 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),
@@ skipping 25 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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) {
@@ skipping 29 matching lines @@
     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)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 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),
@@ skipping 25 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 // 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,
@@ skipping 31 matching lines @@
     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)
+#if defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 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 =
@@ skipping 27 matching lines @@
 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
+#endif  // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)
 
 }  // namespace testing
 
 #endif  // TESTING_GMOCK_MUTANT_H_