diff --git a/include/boost/range/begin.hpp b/include/boost/range/begin.hpp
index b94153b..a8ccc97 100755
--- a/include/boost/range/begin.hpp
+++ b/include/boost/range/begin.hpp
@@ -26,8 +26,11 @@
 
 namespace boost 
 {
+
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))    
 namespace range_detail 
 {
+#endif
     
     //////////////////////////////////////////////////////////////////////
     // primary template
@@ -35,14 +38,14 @@ namespace range_detail
     
     template< typename C >
     inline BOOST_DEDUCED_TYPENAME range_const_iterator<C>::type
-    begin( const C& c )
+    boost_range_begin( const C& c )
     {
         return c.begin(); 
     }
     
     template< typename C >
     inline BOOST_DEDUCED_TYPENAME range_iterator<C>::type
-    begin( C& c )
+    boost_range_begin( C& c )
     {
         return c.begin(); 
     }
@@ -52,13 +55,13 @@ namespace range_detail
     //////////////////////////////////////////////////////////////////////
     
     template< typename Iterator >
-    inline Iterator begin( const std::pair<Iterator,Iterator>& p )
+    inline Iterator boost_range_begin( const std::pair<Iterator,Iterator>& p )
     {
         return p.first;
     }
     
     template< typename Iterator >
-    inline Iterator begin( std::pair<Iterator,Iterator>& p )
+    inline Iterator boost_range_begin( std::pair<Iterator,Iterator>& p )
     {
         return p.first;
     }
@@ -68,13 +71,13 @@ namespace range_detail
     //////////////////////////////////////////////////////////////////////
     
     template< typename T, std::size_t sz >
-    inline const T* begin( const T (&array)[sz] )
+    inline const T* boost_range_begin( const T (&array)[sz] )
     {
         return array;
     }
     
     template< typename T, std::size_t sz >
-    inline T* begin( T (&array)[sz] )
+    inline T* boost_range_begin( T (&array)[sz] )
     {
         return array;
     }
@@ -86,60 +89,68 @@ namespace range_detail
 
 #if 1 || BOOST_WORKAROUND(__MWERKS__, <= 0x3204 ) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 // CW up to 9.3 and borland have troubles with function ordering
-    inline const char* begin( const char* s )
+    inline const char* boost_range_begin( const char* s )
     {
         return s;
     }
 
-    inline char* begin( char* s )
+    inline char* boost_range_begin( char* s )
     {
         return s;
     }
 
-    inline const wchar_t* begin( const wchar_t* s )
+    inline const wchar_t* boost_range_begin( const wchar_t* s )
     {
         return s;
     }
 
-    inline wchar_t* begin( wchar_t* s )
+    inline wchar_t* boost_range_begin( wchar_t* s )
     {
         return s;
     }
 #else
-    inline const char* begin( const char*& s )
+    inline const char* boost_range_begin( const char*& s )
     {
         return s;
     }
     
-    inline char* begin( char*& s )
+    inline char* boost_range_begin( char*& s )
     {
         return s;
     }
     
-    inline const wchar_t* begin( const wchar_t*& s )
+    inline const wchar_t* boost_range_begin( const wchar_t*& s )
     {
         return s;
     }
     
-    inline wchar_t* begin( wchar_t*& s )
+    inline wchar_t* boost_range_begin( wchar_t*& s )
     {
         return s;
     }
 #endif    
 
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))    
 } // namespace 'range_detail'
+#endif
 
 
 template< class T >
 inline BOOST_DEDUCED_TYPENAME range_iterator<T>::type begin( T& r )
 {
-    return range_detail::begin( r );
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+    using namespace range_detail; 
+#endif    
+    return boost_range_begin( r );
 }
 
 template< class T >
 inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type begin( const T& r )
 {
-    return range_detail::begin( r );
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))    
+    using namespace range_detail; 
+#endif    
+    return boost_range_begin( r );
 }
 
 #if BOOST_WORKAROUND(__MWERKS__, <= 0x3003 ) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
@@ -168,7 +179,7 @@ namespace boost
     inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type
     const_begin( const T& r )
     {
-        return begin( r );
+        return boost::begin( r );
     }
 }
 
diff --git a/include/boost/range/detail/mfc/carray.hpp b/include/boost/range/detail/mfc/carray.hpp
index 83c8eb7..71ab5cb 100755
--- a/include/boost/range/detail/mfc/carray.hpp
+++ b/include/boost/range/detail/mfc/carray.hpp
@@ -61,33 +61,33 @@ namespace boost
     };
 
     template< class T, class U >
-    T* begin( CArray<T,U>& r )
+    T* boost_range_begin( CArray<T,U>& r )
     {
         return r.GetData();
     }
         
     template< class T, class U >
-    const T* begin( const CArray<T,U>& r )
+    const T* boost_range_begin( const CArray<T,U>& r )
     {
         return r.GetData();
     }
 
     template< class T, class U >
-    int size( const CArray<T,U>& r )
+    int boost_range_size( const CArray<T,U>& r )
     {
         return r.GetSize();
     }
     
     template< class T, class U >
-    T* end( CArray<T,U>& r )
+    T* boost_range_end( CArray<T,U>& r )
     {
-        return begin( r ) + size( r );
+        return boost_range_begin( r ) + boost_range_size( r );
     }
         
     template< class T, class U >
-    const T* end( const CArray<T,U>& r )
+    const T* boost_range_end( const CArray<T,U>& r )
     {
-        return begin( r ) + size( r );
+        return boost_range_begin( r ) + boost_range_size( r );
     }
 
     // default 'empty()' ok
diff --git a/include/boost/range/detail/mfc/cstring.hpp b/include/boost/range/detail/mfc/cstring.hpp
index d3e9c04..ccb0745 100755
--- a/include/boost/range/detail/mfc/cstring.hpp
+++ b/include/boost/range/detail/mfc/cstring.hpp
@@ -60,29 +60,29 @@ namespace boost
         typedef TCHAR type;
     };
 
-    TCHAR* begin( CString& r )
+    TCHAR* boost_range_begin( CString& r )
     {
         return r.GetBuffer(0);
     }
         
-    const TCHAR* begin( const CString& r )
+    const TCHAR* boost_range_begin( const CString& r )
     {
         return (LPCTSTR)r;
     }
 
-    int size( const CString& r )
+    int boost_range_size( const CString& r )
     {
         return r.GetLength();
     }
     
-    TCHAR* end( CString& r )
+    TCHAR* boost_range_end( CString& r )
     {
-        return begin( r ) + size( r );
+        return boost_range_begin( r ) + boost_range_size( r );
     }
         
-    const TCHAR* end( const CString& r )
+    const TCHAR* range_adl_end( const CString& r )
     {
-        return begin( r ) + size( r );
+        return boost_range_begin( r ) + boost_range_size( r );
     }
 
     // default 'empty()' ok
diff --git a/include/boost/range/end.hpp b/include/boost/range/end.hpp
index 37ad6cd..e7251c7 100755
--- a/include/boost/range/end.hpp
+++ b/include/boost/range/end.hpp
@@ -26,9 +26,12 @@
 #include <boost/range/const_iterator.hpp>
 
 namespace boost 
-{ 
+{
+    
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))     
 namespace range_detail
 {
+#endif   
 
         //////////////////////////////////////////////////////////////////////
         // primary template
@@ -36,14 +39,14 @@ namespace range_detail
         
         template< typename C >
         inline BOOST_DEDUCED_TYPENAME range_const_iterator<C>::type
-        end( const C& c )
+        boost_range_end( const C& c )
         {
             return c.end();
         }
                 
         template< typename C >
         inline BOOST_DEDUCED_TYPENAME range_iterator<C>::type
-        end( C& c )
+        boost_range_end( C& c )
         {
             return c.end();
         }
@@ -53,13 +56,13 @@ namespace range_detail
         //////////////////////////////////////////////////////////////////////
 
         template< typename Iterator >
-        inline Iterator end( const std::pair<Iterator,Iterator>& p )
+        inline Iterator boost_range_end( const std::pair<Iterator,Iterator>& p )
         {
             return p.second;
         }
         
         template< typename Iterator >
-        inline Iterator end( std::pair<Iterator,Iterator>& p )
+        inline Iterator boost_range_end( std::pair<Iterator,Iterator>& p )
         {
             return p.second;
         }
@@ -69,13 +72,13 @@ namespace range_detail
         //////////////////////////////////////////////////////////////////////
 
         template< typename T, std::size_t sz >
-        inline const T* end( const T (&array)[sz] )
+        inline const T* boost_range_end( const T (&array)[sz] )
         {
             return range_detail::array_end<T,sz>( array ); 
         }
         
         template< typename T, std::size_t sz >
-        inline T* end( T (&array)[sz] )
+        inline T* boost_range_end( T (&array)[sz] )
         {
             return range_detail::array_end<T,sz>( array ); 
         }
@@ -86,59 +89,67 @@ namespace range_detail
 
 #if 1 || BOOST_WORKAROUND(__MWERKS__, <= 0x3204 ) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 // CW up to 9.3 and borland have troubles with function ordering
-        inline char* end( char* s )
+        inline char* boost_range_end( char* s )
         {
             return range_detail::str_end( s );
         }
 
-        inline wchar_t* end( wchar_t* s )
+        inline wchar_t* boost_range_end( wchar_t* s )
         {
             return range_detail::str_end( s );
         }
 
-        inline const char* end( const char* s )
+        inline const char* boost_range_end( const char* s )
         {
             return range_detail::str_end( s );
         }
 
-        inline const wchar_t* end( const wchar_t* s )
+        inline const wchar_t* boost_range_end( const wchar_t* s )
         {
             return range_detail::str_end( s );
         }
 #else
-        inline char* end( char*& s )
+        inline char* boost_range_end( char*& s )
         {
             return range_detail::str_end( s );
         }
 
-        inline wchar_t* end( wchar_t*& s )
+        inline wchar_t* boost_range_end( wchar_t*& s )
         {
             return range_detail::str_end( s );
         }
 
-        inline const char* end( const char*& s )
+        inline const char* boost_range_end( const char*& s )
         {
             return range_detail::str_end( s );
         }
 
-        inline const wchar_t* end( const wchar_t*& s )
+        inline const wchar_t* boost_range_end( const wchar_t*& s )
         {
             return range_detail::str_end( s );
         }
 #endif
-        
+
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))        
 } // namespace 'range_detail'
+#endif
 
 template< class T >
 inline BOOST_DEDUCED_TYPENAME range_iterator<T>::type end( T& r )
 {
-    return range_detail::end( r );
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+    using namespace range_detail;
+#endif        
+    return boost_range_end( r );
 }
 
 template< class T >
 inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type end( const T& r )
 {
-    return range_detail::end( r );
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+    using namespace range_detail;
+#endif        
+    return boost_range_end( r );
 }
 
 
@@ -172,7 +183,7 @@ namespace boost
     inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type
     const_end( const T& r )
     {
-        return end( r );
+        return boost::end( r );
     }
 }
 
diff --git a/include/boost/range/iterator_range.hpp b/include/boost/range/iterator_range.hpp
index 8bdd10d..be546f7 100755
--- a/include/boost/range/iterator_range.hpp
+++ b/include/boost/range/iterator_range.hpp
@@ -49,25 +49,28 @@ namespace boost
         {
             typedef BOOST_DEDUCED_TYPENAME boost::range_size<Left>::type sz_type;
 
-            sz_type l_size = size( l ),
-                    r_size = size( r );
+            sz_type l_size = boost::size( l ),
+                    r_size = boost::size( r );
 
             if( l_size != r_size )
                 return false;
 
-            return std::equal( begin(l), end(l), 
-                               begin(r) );                
+            return std::equal( boost::begin(l), boost::end(l), 
+                               boost::begin(r) );                
         }
 
         template< class Left, class Right >
         inline bool less_than( const Left& l, const Right& r )
         {                
-            return std::lexicographical_compare( begin(l), 
-                                                 end(l), 
-                                                 begin(r), 
-                                                 end(r) );                
+            return std::lexicographical_compare( boost::begin(l), 
+                                                 boost::end(l), 
+                                                 boost::begin(r), 
+                                                 boost::end(r) );                
         }
 
+        //
+        // To be deleted...
+        //
         // The functions adl_begin and adl_end are implemented in a separate
         // class for gcc-2.9x
         template<typename IteratorT>
@@ -162,25 +165,25 @@ namespace boost
             //! Constructor from a Range
             template< class Range >
             iterator_range( const Range& r ) : 
-                m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) ), 
+                m_Begin( boost::begin( r ) ), m_End( boost::end( r ) ), 
                 singular(false) {}
 
             //! Constructor from a Range
             template< class Range >
             iterator_range( Range& r ) : 
-                m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) ), 
+                m_Begin( boost::begin( r ) ), m_End( boost::end( r ) ), 
                 singular(false) {}
 
             //! Constructor from a Range
             template< class Range >
             iterator_range( const Range& r, iterator_range_detail::const_range_tag ) : 
-                m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) ), 
+                m_Begin( boost::begin( r ) ), m_End( boost::end( r ) ), 
                 singular(false) {}
 
             //! Constructor from a Range
             template< class Range >
             iterator_range( Range& r, iterator_range_detail::range_tag ) : 
-                m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) ), 
+                m_Begin( boost::begin( r ) ), m_End( boost::end( r ) ), 
                 singular(false) {}
             
             template< class Iterator >
@@ -198,8 +201,8 @@ namespace boost
             template< class ForwardRange >
             iterator_range& operator=( ForwardRange& r )
             {
-                m_Begin  = impl::adl_begin( r ); 
-                m_End    = impl::adl_end( r );
+                m_Begin  = boost::begin( r ); 
+                m_End    = boost::end( r );
                 singular = false;
                 return *this;
             }
@@ -207,8 +210,8 @@ namespace boost
             template< class ForwardRange >
             iterator_range& operator=( const ForwardRange& r )
             {
-                m_Begin  = impl::adl_begin( r ); 
-                m_End    = impl::adl_end( r );
+                m_Begin  = boost::begin( r ); 
+                m_End    = boost::end( r );
                 singular = false;
                 return *this;
             }
@@ -325,7 +328,7 @@ namespace boost
                     std::basic_ostream<Elem, Traits>& Os,
                     const iterator_range<IteratorT>& r )
         {
-            std::copy( begin(r), end(r), std::ostream_iterator<Elem>(Os));
+            std::copy( boost::begin(r), boost::end(r), std::ostream_iterator<Elem>(Os));
             return Os;
         }
 
@@ -341,7 +344,7 @@ namespace boost
                     std::ostream& Os,
                     const iterator_range<IteratorT>& r )
         {
-            std::copy( begin(r), end(r), std::ostream_iterator<char>(Os));
+            std::copy( boost::begin(r), boost::end(r), std::ostream_iterator<char>(Os));
             return Os;
         }
 
@@ -444,7 +447,7 @@ namespace boost
         make_iterator_range( Range& r ) 
         {   
             return iterator_range< BOOST_DEDUCED_TYPENAME range_result_iterator<Range>::type >
-                ( begin( r ), end( r ) );
+                ( boost::begin( r ), boost::end( r ) );
         }
         
 #else
@@ -483,8 +486,8 @@ namespace boost
                     return make_iterator_range( r );
 
                 BOOST_DEDUCED_TYPENAME range_result_iterator<Range>::type 
-                    new_begin = begin( r ),
-                    new_end   = end( r );
+                    new_begin = boost::begin( r ),
+                    new_end   = boost::end( r );
                 std::advance( new_begin, advance_begin );
                 std::advance( new_end, advance_end );
                 return make_iterator_range( new_begin, new_end );
@@ -538,7 +541,7 @@ namespace boost
         template< typename SeqT, typename Range >
         inline SeqT copy_range( const Range& r )
         {
-            return SeqT( begin( r ), end( r ) );
+            return SeqT( boost::begin( r ), boost::end( r ) );
         }
 
 } // namespace 'boost'
diff --git a/include/boost/range/size.hpp b/include/boost/range/size.hpp
index f377153..88201da 100755
--- a/include/boost/range/size.hpp
+++ b/include/boost/range/size.hpp
@@ -29,16 +29,18 @@
 
 namespace boost 
 {
+
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))    
 namespace range_detail 
 {
-
+#endif
         //////////////////////////////////////////////////////////////////////
         // primary template
         //////////////////////////////////////////////////////////////////////
         
         template< typename C >
         inline BOOST_DEDUCED_TYPENAME C::size_type
-        size( const C& c )
+        boost_range_size(  const C& c )
         {
             return c.size(); 
         }
@@ -48,7 +50,7 @@ namespace range_detail
         //////////////////////////////////////////////////////////////////////
 
         template< typename Iterator >
-        inline std::size_t size( const std::pair<Iterator,Iterator>& p )
+        inline std::size_t boost_range_size(  const std::pair<Iterator,Iterator>& p )
         {
             return std::distance( p.first, p.second );
         }
@@ -58,13 +60,13 @@ namespace range_detail
         //////////////////////////////////////////////////////////////////////
 
         template< typename T, std::size_t sz >
-        inline std::size_t size( const T (&array)[sz] )
+        inline std::size_t boost_range_size(  const T (&array)[sz] )
         {
             return range_detail::array_size<T,sz>( array ); 
         }
         
         template< typename T, std::size_t sz >
-        inline std::size_t size( T (&array)[sz] )
+        inline std::size_t boost_range_size(  T (&array)[sz] )
         {
             return boost::range_detail::array_size<T,sz>( array );
         }
@@ -73,37 +75,42 @@ namespace range_detail
         // string
         //////////////////////////////////////////////////////////////////////
 
-        inline std::size_t size( const char* const& s )
+        inline std::size_t boost_range_size(  const char* const& s )
         {
             return boost::range_detail::str_size( s );
         }
 
-        inline std::size_t size( const wchar_t* const& s )
+        inline std::size_t boost_range_size(  const wchar_t* const& s )
         {
             return boost::range_detail::str_size( s );
         }
-        
+
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))                
 } // namespace 'range_detail'
+#endif
 
 template< class T >
-inline BOOST_DEDUCED_TYPENAME range_size<T>::type size( const T& r )
+inline BOOST_DEDUCED_TYPENAME range_size<T>::type size(  const T& r )
 {
-    return range_detail::size( r );
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))        
+    using namespace range_detail;
+#endif    
+    return boost_range_size( r );
 }
 
 
 #if BOOST_WORKAROUND(__MWERKS__, <= 0x3003 ) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 // BCB and CW are not able to overload pointer when class overloads are also available.
-inline range_size<const char*>::type size( const char* r ) {
+inline range_size<const char*>::type size(  const char* r ) {
     return range_detail::str_size( r );
 }
-inline range_size<char*>::type size( char* r ) {
+inline range_size<char*>::type size(  char* r ) {
     return range_detail::str_size( r );
 }
-inline range_size<const wchar_t*>::type size( const wchar_t* r ) {
+inline range_size<const wchar_t*>::type size(  const wchar_t* r ) {
     return range_detail::str_size( r );
 }
-inline range_size<wchar_t*>::type size( wchar_t* r ) {
+inline range_size<wchar_t*>::type size(  wchar_t* r ) {
     return range_detail::str_size( r );
 }
 #endif
diff --git a/include/boost/range/sub_range.hpp b/include/boost/range/sub_range.hpp
index dbc069d..1a92477 100755
--- a/include/boost/range/sub_range.hpp
+++ b/include/boost/range/sub_range.hpp
@@ -44,7 +44,7 @@ namespace boost
         sub_range( ForwardRange2& r ) : 
             
 #if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 800 )
-            base( impl::adl_begin( r ), impl::adl_end( r ) )
+            base( boost::begin( r ), boost::end( r ) )
 #else
             base( r )
 #endif        
@@ -54,7 +54,7 @@ namespace boost
         sub_range( const ForwardRange2& r ) : 
 
 #if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 800 )
-            base( impl::adl_begin( r ), impl::adl_end( r ) )
+            base( boost::begin( r ), boost::end( r ) )
 #else
             base( r )
 #endif