    }
  };
  
-Index: include/gtest/internal/gtest-port.h
-===================================================================
---- include/gtest/internal/gtest-port.h	(revision 655)
-+++ include/gtest/internal/gtest-port.h	(working copy)
-@@ -482,21 +482,21 @@
- #  include <tuple>
- 
- # elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000)
--// GCC 4.0+ implements tr1/tuple in the <tr1/tuple> header.  This does
-+// GCC 4.0+ implements tr1/tuple in the <tuple> header.  This does
- // not conform to the TR1 spec, which requires the header to be <tuple>.
- 
- #  if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
--// Until version 4.3.2, gcc has a bug that causes <tr1/functional>,
--// which is #included by <tr1/tuple>, to not compile when RTTI is
-+// Until version 4.3.2, gcc has a bug that causes <functional>,
-+// which is #included by <tuple>, to not compile when RTTI is
- // disabled.  _TR1_FUNCTIONAL is the header guard for
--// <tr1/functional>.  Hence the following #define is a hack to prevent
--// <tr1/functional> from being included.
-+// <functional>.  Hence the following #define is a hack to prevent
-+// <functional> from being included.
- #   define _TR1_FUNCTIONAL 1
--#   include <tr1/tuple>
-+#   include <tuple>
- #   undef _TR1_FUNCTIONAL  // Allows the user to #include
--                        // <tr1/functional> if he chooses to.
-+                        // <functional> if he chooses to.
- #  else
--#   include <tr1/tuple>  // NOLINT
-+#   include <tuple>  // NOLINT
- #  endif  // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
- 
- # else
 Index: samples/sample8_unittest.cc
 ===================================================================
 --- samples/sample8_unittest.cc	(revision 655)

       TersePrintPrefixToStrings(value, &result);
   return result;
 }
Index: include/gtest/internal/gtest-param-util-generated.h.pump
===================================================================
--- include/gtest/internal/gtest-param-util-generated.h.pump	(revision 655)

 using ::testing::StaticAssertTypeEq;
 
 // Tests that tuple_element<K, tuple<T0, T1, ..., TN> >::type returns TK.
Index: test/gtest-port_test.cc
===================================================================
--- test/gtest-port_test.cc	(revision 655)
+++ test/gtest-port_test.cc	(working copy)
@@ -963,23 +963,23 @@
 }
 
 TEST(ThreadLocalTest, GetAndPointerReturnSameValue) {
-  ThreadLocal<String> thread_local;
+  ThreadLocal<String> thread_local_;
 
-  EXPECT_EQ(thread_local.pointer(), &(thread_local.get()));
+  EXPECT_EQ(thread_local_.pointer(), &(thread_local_.get()));
 
   // Verifies the condition still holds after calling set.
-  thread_local.set("foo");
-  EXPECT_EQ(thread_local.pointer(), &(thread_local.get()));
+  thread_local_.set("foo");
+  EXPECT_EQ(thread_local_.pointer(), &(thread_local_.get()));
 }
 
 TEST(ThreadLocalTest, PointerAndConstPointerReturnSameValue) {
-  ThreadLocal<String> thread_local;
-  const ThreadLocal<String>& const_thread_local = thread_local;
+  ThreadLocal<String> thread_local_;
+  const ThreadLocal<String>& const_thread_local_ = thread_local_;
 
-  EXPECT_EQ(thread_local.pointer(), const_thread_local.pointer());
+  EXPECT_EQ(thread_local_.pointer(), const_thread_local_.pointer());
 
-  thread_local.set("foo");
-  EXPECT_EQ(thread_local.pointer(), const_thread_local.pointer());
+  thread_local_.set("foo");
+  EXPECT_EQ(thread_local_.pointer(), const_thread_local_.pointer());
 }
 
 #if GTEST_IS_THREADSAFE
@@ -1088,14 +1088,14 @@
 }
 
 TEST(ThreadLocalTest, ParameterizedConstructorSetsDefault) {
-  ThreadLocal<String> thread_local("foo");
-  EXPECT_STREQ("foo", thread_local.get().c_str());
+  ThreadLocal<String> thread_local_("foo");
+  EXPECT_STREQ("foo", thread_local_.get().c_str());
 
-  thread_local.set("bar");
-  EXPECT_STREQ("bar", thread_local.get().c_str());
+  thread_local_.set("bar");
+  EXPECT_STREQ("bar", thread_local_.get().c_str());
 
   String result;
-  RunFromThread(&RetrieveThreadLocalValue, make_pair(&thread_local, &result));
+  RunFromThread(&RetrieveThreadLocalValue, make_pair(&thread_local_, &result));
   EXPECT_STREQ("foo", result.c_str());
 }
 
@@ -1124,8 +1124,8 @@
 
 typedef ThreadLocal<DestructorTracker>* ThreadParam;
 
-void CallThreadLocalGet(ThreadParam thread_local) {
-  thread_local->get();
+void CallThreadLocalGet(ThreadParam thread_local_) {
+  thread_local_->get();
 }
 
 // Tests that when a ThreadLocal object dies in a thread, it destroys
@@ -1135,19 +1135,19 @@
 
   {
     // The next line default constructs a DestructorTracker object as
-    // the default value of objects managed by thread_local.
-    ThreadLocal<DestructorTracker> thread_local;
+    // the default value of objects managed by thread_local_.
+    ThreadLocal<DestructorTracker> thread_local_;
     ASSERT_EQ(1U, g_destroyed.size());
     ASSERT_FALSE(g_destroyed[0]);
 
     // This creates another DestructorTracker object for the main thread.
-    thread_local.get();
+    thread_local_.get();
     ASSERT_EQ(2U, g_destroyed.size());
     ASSERT_FALSE(g_destroyed[0]);
     ASSERT_FALSE(g_destroyed[1]);
   }
 
-  // Now thread_local has died.  It should have destroyed both the
+  // Now thread_local_ has died.  It should have destroyed both the
   // default value shared by all threads and the value for the main
   // thread.
   ASSERT_EQ(2U, g_destroyed.size());
@@ -1164,14 +1164,14 @@
 
   {
     // The next line default constructs a DestructorTracker object as
-    // the default value of objects managed by thread_local.
-    ThreadLocal<DestructorTracker> thread_local;
+    // the default value of objects managed by thread_local_.
+    ThreadLocal<DestructorTracker> thread_local_;
     ASSERT_EQ(1U, g_destroyed.size());
     ASSERT_FALSE(g_destroyed[0]);
 
     // This creates another DestructorTracker object in the new thread.
     ThreadWithParam<ThreadParam> thread(
-        &CallThreadLocalGet, &thread_local, NULL);
+        &CallThreadLocalGet, &thread_local_, NULL);
     thread.Join();
 
     // Now the new thread has exited.  The per-thread object for it
@@ -1181,7 +1181,7 @@
     ASSERT_TRUE(g_destroyed[1]);
   }
 
-  // Now thread_local has died.  The default value should have been
+  // Now thread_local_ has died.  The default value should have been
   // destroyed too.
   ASSERT_EQ(2U, g_destroyed.size());
   EXPECT_TRUE(g_destroyed[0]);
@@ -1191,12 +1191,12 @@
 }
 
 TEST(ThreadLocalTest, ThreadLocalMutationsAffectOnlyCurrentThread) {
-  ThreadLocal<String> thread_local;
-  thread_local.set("Foo");
-  EXPECT_STREQ("Foo", thread_local.get().c_str());
+  ThreadLocal<String> thread_local_;
+  thread_local_.set("Foo");
+  EXPECT_STREQ("Foo", thread_local_.get().c_str());
 
   String result;
-  RunFromThread(&RetrieveThreadLocalValue, make_pair(&thread_local, &result));
+  RunFromThread(&RetrieveThreadLocalValue, make_pair(&thread_local_, &result));
   EXPECT_TRUE(result.c_str() == NULL);
 }
 
Index: test/gtest-param-test_test.cc
===================================================================
--- test/gtest-param-test_test.cc	(revision 655)
+++ test/gtest-param-test_test.cc	(working copy)
@@ -64,9 +64,9 @@
 
 # if GTEST_HAS_COMBINE
 using ::testing::Combine;
-using ::std::tr1::get;
-using ::std::tr1::make_tuple;
-using ::std::tr1::tuple;
+using ::std::get;
+using ::std::make_tuple;
+using ::std::tuple;
 # endif  // GTEST_HAS_COMBINE
 
 using ::testing::internal::ParamGenerator;
Index: test/gtest-printers_test.cc
===================================================================
--- test/gtest-printers_test.cc	(revision 655)
