diff --git a/adobe/move.hpp b/adobe/move.hpp
index 350000d..5fe6db5 100644
--- a/adobe/move.hpp
+++ b/adobe/move.hpp
@@ -441,7 +441,7 @@ with move semantics, for movable types, otherwise with copy semantics.
 template <typename I, // I models BidirectionalRange
           typename O> // O models BidirectionalIterator
 inline O move_backward(I& in, O out)
-{ return move_backward(boost::begin(in), boost::end(in), 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 926cfa9..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>
@@ -354,7 +354,7 @@ typename vector<T, A>::iterator vector<T, A>::insert(iterator p, I f, I l, std::
         
         if (n < after) {
             append_move(last - n, last);
-            move_backward(p, last - n, last);
+            adobe::move_backward(p, last - n, last);
             std::copy(f, l, p);
         } else {
             I m = f;
@@ -387,7 +387,7 @@ typename vector<T, A>::iterator vector<T, A>::insert_move(iterator p, I f, I l)
         
         if (n < after) {
             append_move(last - n, last);
-            move_backward(p, last - n, last);
+            adobe::move_backward(p, last - n, last);
             adobe::move(f, l, p);
         } else {
             I m = f;
@@ -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);
     }
 }
@@ -430,7 +430,7 @@ typename vector<T, A>::iterator vector<T, A>::insert(iterator p, size_type n, co
         
         if (n < after) {
             append_move(last - n, last);
-            move_backward(p, last - n, last);
+            adobe::move_backward(p, last - n, last);
             std::fill_n(p, n, x);
         } else {
             std::uninitialized_fill_n(last, n - after, x);