diff --git a/adobe/move.hpp b/adobe/move.hpp

index 350000d..6c302a2 100644

--- a/adobe/move.hpp

+++ b/adobe/move.hpp

@@ -440,8 +440,8 @@ with move semantics, for movable types, otherwise with copy semantics.

 */

 template 

           typename O> // O models BidirectionalIterator

-inline O move_backward(I& in, O out)

-{ return move_backward(boost::begin(in), boost::end(in), out); }

+inline O adobe::move_backward(I& in, O out)

+{ return adobe::move_backward(boost::begin(in), boost::end(in), out); }

 /*************************************************************************************************/

diff --git a/adobe/once.hpp b/adobe/once.hpp

index 5f005a4..e349b92 100644

--- a/adobe/once.hpp

+++ b/adobe/once.hpp

@@ -11,12 +11,12 @@

 /*************************************************************************************************/

-#include <adobe/config.hpp>

-

 #if defined(BOOST_HAS_THREADS)

     #include <boost/thread.hpp>

 #endif

+#include <adobe/config.hpp>

+

 /*************************************************************************************************/

 namespace adobe {

diff --git a/adobe/vector.hpp b/adobe/vector.hpp

index 2d23e59..8968b59 100644

--- a/adobe/vector.hpp

+++ b/adobe/vector.hpp

@@ -319,7 +319,7 @@ void vector<T, A>::append_move(I f, I l, std::forward_iterator_tag)

     size_type n(std::distance(f, l));

 	if (remaining() < n) reserve((adobe::max)(size() + n, 2 * size()));

-    set_finish(uninitialized_move(f, l, end()));

+    set_finish(adobe::uninitialized_move(f, l, end()));

 }

 template <typename T, typename A>

@@ -406,7 +406,7 @@ void vector<T, A>::reserve(size_type n)

     if (capacity() < n) {

         vector tmp;

         tmp.header_m = allocate(get_allocator(), n);

-        tmp.header_m->finish() = uninitialized_move(begin(), end(), tmp.end());

+        tmp.header_m->finish() = adobe::uninitialized_move(begin(), end(), tmp.end());

         swap(tmp);

     }

 }