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 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);