Index: boost/random/lagged_fibonacci.hpp
===================================================================
--- boost/random/lagged_fibonacci.hpp	(revision 86188)
+++ boost/random/lagged_fibonacci.hpp	(working copy)
@@ -143,8 +143,8 @@
     BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, lagged_fibonacci_engine, f)
     {
         os << f.i;
-        for(unsigned int i = 0; i < f.long_lag; ++i)
-            os << ' ' << f.x[i];
+        for(unsigned int j = 0; j < f.long_lag; ++j)
+            os << ' ' << f.x[j];
         return os;
     }
     
@@ -154,8 +154,8 @@
     BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, lagged_fibonacci_engine, f)
     {
         is >> f.i >> std::ws;
-        for(unsigned int i = 0; i < f.long_lag; ++i)
-            is >> f.x[i] >> std::ws;
+        for(unsigned int j = 0; j < f.long_lag; ++j)
+            is >> f.x[j] >> std::ws;
         return is;
     }
     
@@ -163,8 +163,8 @@
      * Returns true if the two generators will produce identical
      * sequences of outputs.
      */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(lagged_fibonacci_engine, x, y)
-    { return x.i == y.i && std::equal(x.x, x.x+long_lag, y.x); }
+    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(lagged_fibonacci_engine, x_, y_)
+    { return x_.i == y_.i && std::equal(x_.x, x_.x+long_lag, y_.x); }
     
     /**
      * Returns true if the two generators will produce different
@@ -354,8 +354,8 @@
         using std::pow;
         os << f.i;
         std::ios_base::fmtflags oldflags = os.flags(os.dec | os.fixed | os.left); 
-        for(unsigned int i = 0; i < f.long_lag; ++i)
-            os << ' ' << f.x[i] * f.modulus();
+        for(unsigned int j = 0; j < f.long_lag; ++j)
+            os << ' ' << f.x[j] * f.modulus();
         os.flags(oldflags);
         return os;
     }
@@ -366,10 +366,10 @@
     BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, lagged_fibonacci_01_engine, f)
     {
         is >> f.i;
-        for(unsigned int i = 0; i < f.long_lag; ++i) {
+        for(unsigned int j = 0; j < f.long_lag; ++j) {
             typename lagged_fibonacci_01_engine::result_type value;
             is >> std::ws >> value;
-            f.x[i] = value / f.modulus();
+            f.x[j] = value / f.modulus();
         }
         return is;
     }
@@ -378,8 +378,8 @@
      * Returns true if the two generators will produce identical
      * sequences of outputs.
      */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(lagged_fibonacci_01_engine, x, y)
-    { return x.i == y.i && std::equal(x.x, x.x+long_lag, y.x); }
+    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(lagged_fibonacci_01_engine, x_, y_)
+    { return x_.i == y_.i && std::equal(x_.x, x_.x+long_lag, y_.x); }
     
     /**
      * Returns true if the two generators will produce different
Index: boost/random/mersenne_twister.hpp
===================================================================
--- boost/random/mersenne_twister.hpp	(revision 86188)
+++ boost/random/mersenne_twister.hpp	(working copy)
@@ -234,19 +234,19 @@
      * Returns true if the two generators are in the same state,
      * and will thus produce identical sequences.
      */
-    friend bool operator==(const mersenne_twister_engine& x,
-                           const mersenne_twister_engine& y)
+    friend bool operator==(const mersenne_twister_engine& x_,
+                           const mersenne_twister_engine& y_)
     {
-        if(x.i < y.i) return x.equal_imp(y);
-        else return y.equal_imp(x);
+        if(x_.i < y_.i) return x_.equal_imp(y_);
+        else return y_.equal_imp(x_);
     }
     
     /**
      * Returns true if the two generators are in different states.
      */
-    friend bool operator!=(const mersenne_twister_engine& x,
-                           const mersenne_twister_engine& y)
-    { return !(x == y); }
+    friend bool operator!=(const mersenne_twister_engine& x_,
+                           const mersenne_twister_engine& y_)
+    { return !(x_ == y_); }
 
 private:
     /// \cond show_private