diff --git a/include/boost/functional.hpp b/include/boost/functional.hpp
new file mode 100644
index 0000000..6443078
--- /dev/null
+++ b/include/boost/functional.hpp
@@ -0,0 +1,581 @@
+// ------------------------------------------------------------------------------
+// Copyright (c) 2000 Cadenza New Zealand Ltd
+// Distributed under the Boost Software License, Version 1.0. (See accompany-
+// ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+// ------------------------------------------------------------------------------
+// Boost functional.hpp header file
+// See http://www.boost.org/libs/functional for documentation.
+// ------------------------------------------------------------------------------
+// $Id$
+// ------------------------------------------------------------------------------
+
+#ifndef BOOST_FUNCTIONAL_HPP
+#define BOOST_FUNCTIONAL_HPP
+
+#include <boost/config.hpp>
+#include <boost/call_traits.hpp>
+#include <functional>
+
+namespace boost
+{
+    namespace functional
+    {
+        namespace detail {
+#if defined(_HAS_AUTO_PTR_ETC) && !_HAS_AUTO_PTR_ETC
+            // std::unary_function and std::binary_function were both removed
+            // in C++17.
+
+            template <typename Arg1, typename Result>
+            struct unary_function
+            {
+                typedef Arg1 argument_type;
+                typedef Result result_type;
+            };
+
+            template <typename Arg1, typename Arg2, typename Result>
+            struct binary_function
+            {
+                typedef Arg1 first_argument_type;
+                typedef Arg2 second_argument_type;
+                typedef Result result_type;
+            };
+#else
+            // Use the standard objects when we have them.
+
+            using std::unary_function;
+            using std::binary_function;
+#endif
+        }
+    }
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    // --------------------------------------------------------------------------
+    // The following traits classes allow us to avoid the need for ptr_fun
+    // because the types of arguments and the result of a function can be 
+    // deduced.
+    //
+    // In addition to the standard types defined in unary_function and 
+    // binary_function, we add
+    //
+    // - function_type, the type of the function or function object itself.
+    //
+    // - param_type, the type that should be used for passing the function or
+    //   function object as an argument.
+    // --------------------------------------------------------------------------
+    namespace detail
+    {
+        template <class Operation>
+        struct unary_traits_imp;
+        
+        template <class Operation>
+        struct unary_traits_imp<Operation*>
+        {
+            typedef Operation                         function_type;
+            typedef const function_type &             param_type;
+            typedef typename Operation::result_type   result_type;
+            typedef typename Operation::argument_type argument_type;
+        };
+
+        template <class R, class A>
+        struct unary_traits_imp<R(*)(A)>
+        {
+            typedef R (*function_type)(A);
+            typedef R (*param_type)(A);
+            typedef R result_type;
+            typedef A argument_type;
+        };
+
+        template <class Operation>
+        struct binary_traits_imp;
+
+        template <class Operation>
+        struct binary_traits_imp<Operation*>
+        {
+            typedef Operation                                function_type;
+            typedef const function_type &                    param_type;
+            typedef typename Operation::result_type          result_type;
+            typedef typename Operation::first_argument_type  first_argument_type;
+            typedef typename Operation::second_argument_type second_argument_type;
+        };
+        
+        template <class R, class A1, class A2>
+        struct binary_traits_imp<R(*)(A1,A2)>
+        {
+            typedef R (*function_type)(A1,A2);
+            typedef R (*param_type)(A1,A2);
+            typedef R result_type;
+            typedef A1 first_argument_type;
+            typedef A2 second_argument_type;
+        };
+    } // namespace detail
+    
+    template <class Operation>
+    struct unary_traits
+    {
+        typedef typename detail::unary_traits_imp<Operation*>::function_type function_type;
+        typedef typename detail::unary_traits_imp<Operation*>::param_type    param_type;
+        typedef typename detail::unary_traits_imp<Operation*>::result_type   result_type;
+        typedef typename detail::unary_traits_imp<Operation*>::argument_type argument_type;
+    }; 
+
+    template <class R, class A>
+    struct unary_traits<R(*)(A)>
+    {
+        typedef R (*function_type)(A);
+        typedef R (*param_type)(A);
+        typedef R result_type;
+        typedef A argument_type;
+    };
+
+    template <class Operation>
+    struct binary_traits
+    {
+        typedef typename detail::binary_traits_imp<Operation*>::function_type        function_type;
+        typedef typename detail::binary_traits_imp<Operation*>::param_type           param_type;
+        typedef typename detail::binary_traits_imp<Operation*>::result_type          result_type;
+        typedef typename detail::binary_traits_imp<Operation*>::first_argument_type  first_argument_type;
+        typedef typename detail::binary_traits_imp<Operation*>::second_argument_type second_argument_type;
+    };
+    
+    template <class R, class A1, class A2>
+    struct binary_traits<R(*)(A1,A2)>
+    {
+        typedef R (*function_type)(A1,A2);
+        typedef R (*param_type)(A1,A2);
+        typedef R result_type;
+        typedef A1 first_argument_type;
+        typedef A2 second_argument_type;
+    };
+#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    // --------------------------------------------------------------------------
+    // If we have no partial specialisation available, decay to a situation
+    // that is no worse than in the Standard, i.e., ptr_fun will be required.
+    // --------------------------------------------------------------------------
+
+    template <class Operation>
+    struct unary_traits
+    {
+        typedef Operation                         function_type;
+        typedef const Operation&                  param_type;
+        typedef typename Operation::result_type   result_type;
+        typedef typename Operation::argument_type argument_type;
+    }; 
+    
+    template <class Operation>
+    struct binary_traits
+    {
+        typedef Operation                                function_type;
+        typedef const Operation &                        param_type;
+        typedef typename Operation::result_type          result_type;
+        typedef typename Operation::first_argument_type  first_argument_type;
+        typedef typename Operation::second_argument_type second_argument_type;
+    };    
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    
+    // --------------------------------------------------------------------------
+    // unary_negate, not1
+    // --------------------------------------------------------------------------
+    template <class Predicate>
+    class unary_negate
+        : public boost::functional::detail::unary_function<typename unary_traits<Predicate>::argument_type,bool>
+    {
+      public:
+        explicit unary_negate(typename unary_traits<Predicate>::param_type x)
+            :
+            pred(x)
+        {}
+        bool operator()(typename call_traits<typename unary_traits<Predicate>::argument_type>::param_type x) const
+        {
+            return !pred(x);
+        }
+      private:
+        typename unary_traits<Predicate>::function_type pred;
+    };
+
+    template <class Predicate>
+    unary_negate<Predicate> not1(const Predicate &pred)
+    {
+        // The cast is to placate Borland C++Builder in certain circumstances.
+        // I don't think it should be necessary.
+        return unary_negate<Predicate>((typename unary_traits<Predicate>::param_type)pred);
+    }
+
+    template <class Predicate>
+    unary_negate<Predicate> not1(Predicate &pred)
+    {
+        return unary_negate<Predicate>(pred);
+    }
+
+    // --------------------------------------------------------------------------
+    // binary_negate, not2
+    // --------------------------------------------------------------------------
+    template <class Predicate>
+    class binary_negate
+        : public boost::functional::detail::binary_function<
+                                      typename binary_traits<Predicate>::first_argument_type,
+                                      typename binary_traits<Predicate>::second_argument_type,
+                                      bool>
+    {
+      public:
+        explicit binary_negate(typename binary_traits<Predicate>::param_type x)
+            :
+            pred(x)
+        {}
+        bool operator()(typename call_traits<typename binary_traits<Predicate>::first_argument_type>::param_type x,
+                        typename call_traits<typename binary_traits<Predicate>::second_argument_type>::param_type y) const
+        {
+            return !pred(x,y);
+        }
+      private:
+        typename binary_traits<Predicate>::function_type pred;
+    };
+
+    template <class Predicate>
+    binary_negate<Predicate> not2(const Predicate &pred)
+    {
+        // The cast is to placate Borland C++Builder in certain circumstances.
+        // I don't think it should be necessary.
+        return binary_negate<Predicate>((typename binary_traits<Predicate>::param_type)pred);
+    }
+
+    template <class Predicate>
+    binary_negate<Predicate> not2(Predicate &pred)
+    {
+        return binary_negate<Predicate>(pred);
+    }
+        
+    // --------------------------------------------------------------------------
+    // binder1st, bind1st
+    // --------------------------------------------------------------------------
+    template <class Operation>
+    class binder1st
+        : public boost::functional::detail::unary_function<
+                                     typename binary_traits<Operation>::second_argument_type,
+                                     typename binary_traits<Operation>::result_type>
+    {       
+      public:
+        binder1st(typename binary_traits<Operation>::param_type x,
+                  typename call_traits<typename binary_traits<Operation>::first_argument_type>::param_type y)
+            :
+            op(x), value(y)
+        {}
+        
+        typename binary_traits<Operation>::result_type
+        operator()(typename call_traits<typename binary_traits<Operation>::second_argument_type>::param_type x) const
+        {
+            return op(value, x);
+        }
+        
+      protected:
+        typename binary_traits<Operation>::function_type op;
+        typename binary_traits<Operation>::first_argument_type value;
+    };
+
+    template <class Operation>
+    inline binder1st<Operation> bind1st(const Operation &op,
+                                        typename call_traits<
+                                                    typename binary_traits<Operation>::first_argument_type
+                                        >::param_type x)
+    {
+        // The cast is to placate Borland C++Builder in certain circumstances.
+        // I don't think it should be necessary.
+        return binder1st<Operation>((typename binary_traits<Operation>::param_type)op, x);
+    }
+
+    template <class Operation>
+    inline binder1st<Operation> bind1st(Operation &op,
+                                        typename call_traits<
+                                                    typename binary_traits<Operation>::first_argument_type
+                                        >::param_type x)
+    {
+        return binder1st<Operation>(op, x);
+    }
+
+    // --------------------------------------------------------------------------
+    // binder2nd, bind2nd
+    // --------------------------------------------------------------------------
+    template <class Operation>
+    class binder2nd
+        : public boost::functional::detail::unary_function<
+                                     typename binary_traits<Operation>::first_argument_type,
+                                     typename binary_traits<Operation>::result_type>
+    {
+      public:
+        binder2nd(typename binary_traits<Operation>::param_type x,
+                  typename call_traits<typename binary_traits<Operation>::second_argument_type>::param_type y)
+            :
+            op(x), value(y)
+        {}
+        
+        typename binary_traits<Operation>::result_type
+        operator()(typename call_traits<typename binary_traits<Operation>::first_argument_type>::param_type x) const
+        {
+            return op(x, value);
+        }               
+        
+      protected:
+        typename binary_traits<Operation>::function_type op;
+        typename binary_traits<Operation>::second_argument_type value;
+    };
+
+    template <class Operation>
+    inline binder2nd<Operation> bind2nd(const Operation &op,
+                                        typename call_traits<
+                                                    typename binary_traits<Operation>::second_argument_type
+                                        >::param_type x)
+    {
+        // The cast is to placate Borland C++Builder in certain circumstances.
+        // I don't think it should be necessary.
+        return binder2nd<Operation>((typename binary_traits<Operation>::param_type)op, x);
+    }
+
+    template <class Operation>
+    inline binder2nd<Operation> bind2nd(Operation &op,
+                                        typename call_traits<
+                                                    typename binary_traits<Operation>::second_argument_type
+                                        >::param_type x)
+    {
+        return binder2nd<Operation>(op, x);
+    }
+
+    // --------------------------------------------------------------------------
+    // mem_fun, etc
+    // --------------------------------------------------------------------------
+    template <class S, class T>
+    class mem_fun_t : public boost::functional::detail::unary_function<T*, S>
+    {
+      public:
+        explicit mem_fun_t(S (T::*p)())
+            :
+            ptr(p)
+        {}
+        S operator()(T* p) const
+        {
+            return (p->*ptr)();
+        }
+      private:
+        S (T::*ptr)();
+    };
+
+    template <class S, class T, class A>
+    class mem_fun1_t : public boost::functional::detail::binary_function<T*, A, S>
+    {
+      public:   
+        explicit mem_fun1_t(S (T::*p)(A))
+            :
+            ptr(p)
+        {}
+        S operator()(T* p, typename call_traits<A>::param_type x) const
+        {
+            return (p->*ptr)(x);
+        }
+      private:
+        S (T::*ptr)(A);
+    };
+
+    template <class S, class T>
+    class const_mem_fun_t : public boost::functional::detail::unary_function<const T*, S>
+    {
+      public:
+        explicit const_mem_fun_t(S (T::*p)() const)
+            :
+            ptr(p)
+        {}
+        S operator()(const T* p) const
+        {
+            return (p->*ptr)();
+        }
+      private:
+        S (T::*ptr)() const;        
+    };
+
+    template <class S, class T, class A>
+    class const_mem_fun1_t : public boost::functional::detail::binary_function<const T*, A, S>
+    {
+      public:
+        explicit const_mem_fun1_t(S (T::*p)(A) const)
+            :
+            ptr(p)
+        {}
+        S operator()(const T* p, typename call_traits<A>::param_type x) const
+        {
+            return (p->*ptr)(x);
+        }
+      private:
+        S (T::*ptr)(A) const;
+    };
+    
+    template<class S, class T>
+    inline mem_fun_t<S,T> mem_fun(S (T::*f)())
+    {
+        return mem_fun_t<S,T>(f);
+    }
+    
+    template<class S, class T, class A>
+    inline mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A))
+    {
+        return mem_fun1_t<S,T,A>(f);
+    }
+
+#ifndef BOOST_NO_POINTER_TO_MEMBER_CONST
+    template<class S, class T>
+    inline const_mem_fun_t<S,T> mem_fun(S (T::*f)() const)
+    {
+        return const_mem_fun_t<S,T>(f);
+    }
+    
+    template<class S, class T, class A>
+    inline const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const)
+    {
+        return const_mem_fun1_t<S,T,A>(f);
+    }
+#endif // BOOST_NO_POINTER_TO_MEMBER_CONST
+
+    // --------------------------------------------------------------------------
+    // mem_fun_ref, etc
+    // --------------------------------------------------------------------------
+    template <class S, class T>
+    class mem_fun_ref_t : public boost::functional::detail::unary_function<T&, S>
+    {
+      public:
+        explicit mem_fun_ref_t(S (T::*p)())
+            :
+            ptr(p)
+        {}
+        S operator()(T& p) const
+        {
+            return (p.*ptr)();
+        }
+      private:
+        S (T::*ptr)();
+    };
+
+    template <class S, class T, class A>
+    class mem_fun1_ref_t : public boost::functional::detail::binary_function<T&, A, S>
+    {
+      public:
+        explicit mem_fun1_ref_t(S (T::*p)(A))
+            :
+            ptr(p)
+        {}
+        S operator()(T& p, typename call_traits<A>::param_type x) const
+        {
+            return (p.*ptr)(x);
+        }
+      private:
+        S (T::*ptr)(A);
+    };
+    
+    template <class S, class T>
+    class const_mem_fun_ref_t : public boost::functional::detail::unary_function<const T&, S>
+    {
+      public:
+        explicit const_mem_fun_ref_t(S (T::*p)() const)
+            :
+            ptr(p)
+        {}
+        
+        S operator()(const T &p) const
+        {
+            return (p.*ptr)();
+        }
+      private:
+        S (T::*ptr)() const;
+    };
+
+    template <class S, class T, class A>
+    class const_mem_fun1_ref_t : public boost::functional::detail::binary_function<const T&, A, S>
+    {
+      public:
+        explicit const_mem_fun1_ref_t(S (T::*p)(A) const)
+            :
+            ptr(p)
+        {}
+
+        S operator()(const T& p, typename call_traits<A>::param_type x) const
+        {
+            return (p.*ptr)(x);
+        }
+      private:
+        S (T::*ptr)(A) const;
+    };
+    
+    template<class S, class T>
+    inline mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)())
+    {
+        return mem_fun_ref_t<S,T>(f);
+    }
+
+    template<class S, class T, class A>
+    inline mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A))
+    {
+        return mem_fun1_ref_t<S,T,A>(f);
+    }
+
+#ifndef BOOST_NO_POINTER_TO_MEMBER_CONST
+    template<class S, class T>
+    inline const_mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)() const)
+    {
+        return const_mem_fun_ref_t<S,T>(f);
+    }
+
+    template<class S, class T, class A>
+    inline const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const)
+    {
+        return const_mem_fun1_ref_t<S,T,A>(f);
+    }   
+#endif // BOOST_NO_POINTER_TO_MEMBER_CONST
+
+    // --------------------------------------------------------------------------
+    // ptr_fun
+    // --------------------------------------------------------------------------
+    template <class Arg, class Result>
+    class pointer_to_unary_function : public boost::functional::detail::unary_function<Arg,Result>
+    {
+      public:
+        explicit pointer_to_unary_function(Result (*f)(Arg))
+            :
+            func(f)
+        {}
+
+        Result operator()(typename call_traits<Arg>::param_type x) const
+        {
+            return func(x);
+        }
+        
+      private:
+        Result (*func)(Arg);
+    };
+
+    template <class Arg, class Result>
+    inline pointer_to_unary_function<Arg,Result> ptr_fun(Result (*f)(Arg))
+    {
+        return pointer_to_unary_function<Arg,Result>(f);
+    }
+
+    template <class Arg1, class Arg2, class Result>
+    class pointer_to_binary_function : public boost::functional::detail::binary_function<Arg1,Arg2,Result>
+    {
+      public:
+        explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2))
+            :
+            func(f)
+        {}
+        
+        Result operator()(typename call_traits<Arg1>::param_type x, typename call_traits<Arg2>::param_type y) const
+        {
+            return func(x,y);
+        }
+        
+      private:
+        Result (*func)(Arg1, Arg2);
+    };
+
+    template <class Arg1, class Arg2, class Result>
+    inline pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*f)(Arg1, Arg2))
+    {
+        return pointer_to_binary_function<Arg1,Arg2,Result>(f);
+    }
+} // namespace boost
+
+#endif
diff --git a/include/boost/functional/factory.hpp b/include/boost/functional/factory.hpp
new file mode 100644
index 0000000..92f67d9
--- /dev/null
+++ b/include/boost/functional/factory.hpp
@@ -0,0 +1,214 @@
+/*=============================================================================
+    Copyright (c) 2007 Tobias Schwinger
+  
+    Use modification and distribution are subject to the Boost Software 
+    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+==============================================================================*/
+
+#ifndef BOOST_FUNCTIONAL_FACTORY_HPP_INCLUDED
+#   ifndef BOOST_PP_IS_ITERATING
+
+#     include <boost/preprocessor/iteration/iterate.hpp>
+#     include <boost/preprocessor/repetition/enum_params.hpp>
+#     include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#     include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+
+#     include <new>
+#     include <boost/pointee.hpp>
+#     include <boost/get_pointer.hpp>
+#     include <boost/non_type.hpp>
+#     include <boost/type_traits/remove_cv.hpp>
+
+#     if defined(BOOST_FUNCTIONAL_FACTORY_SUPPORT_NONE_T)
+#       include <boost/none_t.hpp>
+#     endif
+
+#     ifndef BOOST_FUNCTIONAL_FACTORY_MAX_ARITY
+#       define BOOST_FUNCTIONAL_FACTORY_MAX_ARITY 10
+#     elif BOOST_FUNCTIONAL_FACTORY_MAX_ARITY < 3
+#       undef  BOOST_FUNCTIONAL_FACTORY_MAX_ARITY
+#       define BOOST_FUNCTIONAL_FACTORY_MAX_ARITY 3
+#     endif
+
+namespace boost
+{
+    enum factory_alloc_propagation
+    {
+        factory_alloc_for_pointee_and_deleter,
+        factory_passes_alloc_to_smart_pointer
+    };
+
+#if defined(BOOST_FUNCTIONAL_FACTORY_SUPPORT_NONE_T)
+    template< typename Pointer, class Allocator = boost::none_t,
+        factory_alloc_propagation AP = factory_alloc_for_pointee_and_deleter >
+    class factory;
+#else
+    template< typename Pointer, class Allocator = void,
+        factory_alloc_propagation AP = factory_alloc_for_pointee_and_deleter >
+    class factory;
+#endif
+
+    //----- ---- --- -- - -  -   -
+
+    template< typename Pointer, factory_alloc_propagation AP >
+    class factory<Pointer, void, AP>
+    {
+      public:
+        typedef typename boost::remove_cv<Pointer>::type result_type;
+        typedef typename boost::pointee<result_type>::type value_type;
+
+        factory()
+        { }
+
+#     define BOOST_PP_FILENAME_1 <boost/functional/factory.hpp>
+#     define BOOST_PP_ITERATION_LIMITS (0,BOOST_FUNCTIONAL_FACTORY_MAX_ARITY)
+#     include BOOST_PP_ITERATE()
+    };
+
+#if defined(BOOST_FUNCTIONAL_FACTORY_SUPPORT_NONE_T)
+    template< typename Pointer, factory_alloc_propagation AP >
+    class factory<Pointer, boost::none_t, AP>
+        : public factory<Pointer, void, AP>
+    {};
+#endif
+
+    template< class Pointer, class Allocator, factory_alloc_propagation AP >
+    class factory
+#if defined(BOOST_NO_CXX11_ALLOCATOR)
+        : private Allocator::template rebind< typename boost::pointee<
+            typename boost::remove_cv<Pointer>::type >::type >::other
+#else
+        : private std::allocator_traits<Allocator>::template rebind_alloc<
+            typename boost::pointee< typename boost::remove_cv<Pointer>::type >::type >
+#endif
+    {
+      public:
+        typedef typename boost::remove_cv<Pointer>::type result_type;
+        typedef typename boost::pointee<result_type>::type value_type;
+
+#if defined(BOOST_NO_CXX11_ALLOCATOR)
+        typedef typename Allocator::template rebind<value_type>::other
+            allocator_type;
+#else
+        typedef typename std::allocator_traits<Allocator>::template rebind_alloc<value_type>
+            allocator_type;
+        typedef std::allocator_traits<allocator_type> allocator_traits;
+#endif
+
+        explicit factory(allocator_type const & a = allocator_type())
+          : allocator_type(a)
+        { }
+
+      private:
+
+        struct deleter
+            : allocator_type
+        {
+            inline deleter(allocator_type const& that) 
+              : allocator_type(that)
+            { }
+
+            allocator_type& get_allocator() const
+            {
+                return *const_cast<allocator_type*>(
+                    static_cast<allocator_type const*>(this));
+            }
+
+            void operator()(value_type* ptr) const
+            {
+                if (!! ptr) {
+#if defined(BOOST_NO_CXX11_ALLOCATOR)
+                    ptr->~value_type();
+                    const_cast<allocator_type*>(static_cast<allocator_type const*>(
+                        this))->deallocate(ptr,1);
+#else
+                    allocator_traits::destroy(this->get_allocator(), ptr);
+                    allocator_traits::deallocate(this->get_allocator(),ptr,1);
+#endif
+                }
+            }
+        };
+
+        inline allocator_type& get_allocator() const
+        {
+            return *const_cast<allocator_type*>(
+                static_cast<allocator_type const*>(this));
+        }
+
+        inline result_type make_pointer(value_type* ptr, boost::non_type<
+            factory_alloc_propagation,factory_passes_alloc_to_smart_pointer>)
+        const
+        {
+            return result_type(ptr,deleter(this->get_allocator()));
+        }
+        inline result_type make_pointer(value_type* ptr, boost::non_type<
+            factory_alloc_propagation,factory_alloc_for_pointee_and_deleter>)
+        const
+        {
+            return result_type(ptr,deleter(this->get_allocator()),
+                this->get_allocator());
+        }
+
+      public:
+
+#     define BOOST_TMP_MACRO
+#     define BOOST_PP_FILENAME_1 <boost/functional/factory.hpp>
+#     define BOOST_PP_ITERATION_LIMITS (0,BOOST_FUNCTIONAL_FACTORY_MAX_ARITY)
+#     include BOOST_PP_ITERATE()
+#     undef BOOST_TMP_MACRO
+    };
+
+    template< typename Pointer, class Allocator, factory_alloc_propagation AP > 
+    class factory<Pointer&, Allocator, AP>;
+    // forbidden, would create a dangling reference
+}
+
+#     define BOOST_FUNCTIONAL_FACTORY_HPP_INCLUDED
+#   else // defined(BOOST_PP_IS_ITERATING)
+#     define N BOOST_PP_ITERATION()
+#     if !defined(BOOST_TMP_MACRO)
+#       if N > 0
+    template< BOOST_PP_ENUM_PARAMS(N, typename T) >
+#       endif
+    inline result_type operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,T,& a)) const
+    {
+        return result_type( new value_type(BOOST_PP_ENUM_PARAMS(N,a)) );
+    }
+#     else // defined(BOOST_TMP_MACRO)
+#       if N > 0
+    template< BOOST_PP_ENUM_PARAMS(N, typename T) >
+#       endif
+    inline result_type operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,T,& a)) const
+    {
+#if defined(BOOST_NO_CXX11_ALLOCATOR)
+        value_type* memory = this->get_allocator().allocate(1);
+#else
+        value_type* memory = allocator_traits::allocate(this->get_allocator(), 1);
+#endif
+        try
+        {
+#if defined(BOOST_NO_CXX11_ALLOCATOR)
+            new(memory) value_type(BOOST_PP_ENUM_PARAMS(N,a));
+#else
+            allocator_traits::construct(this->get_allocator(), memory
+                BOOST_PP_ENUM_TRAILING_PARAMS(N,a));
+#endif
+        }
+        catch (...) {
+#if defined(BOOST_NO_CXX11_ALLOCATOR)
+            this->get_allocator().deallocate(memory,1);
+#else
+            allocator_traits::deallocate(this->get_allocator(), memory, 1);
+#endif
+            throw;
+        }
+
+        return make_pointer(memory, boost::non_type<factory_alloc_propagation,AP>());
+    }
+#     endif
+#     undef N
+#   endif // defined(BOOST_PP_IS_ITERATING)
+
+#endif // include guard
+
diff --git a/include/boost/functional/forward_adapter.hpp b/include/boost/functional/forward_adapter.hpp
new file mode 100644
index 0000000..0d486a6
--- /dev/null
+++ b/include/boost/functional/forward_adapter.hpp
@@ -0,0 +1,501 @@
+/*=============================================================================
+    Copyright (c) 2007-2008 Tobias Schwinger
+  
+    Use modification and distribution are subject to the Boost Software 
+    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).  
+==============================================================================*/
+
+#ifndef BOOST_FUNCTIONAL_FORWARD_ADAPTER_HPP_INCLUDED
+#   ifndef BOOST_PP_IS_ITERATING
+
+#   include <boost/config.hpp>
+#   include <boost/config/workaround.hpp>
+
+#   include <boost/preprocessor/iteration/iterate.hpp>
+#   include <boost/preprocessor/repetition/enum_params.hpp>
+#   include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#   include <boost/preprocessor/facilities/intercept.hpp>
+#   include <boost/preprocessor/arithmetic/dec.hpp>
+
+#   include <boost/utility/result_of.hpp>
+
+#   ifndef BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY
+#     define BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY 6
+#   elif BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY < 3
+#     undef  BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY
+#     define BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY 3
+#   endif
+
+
+namespace boost 
+{
+    template< typename Function, int Arity_Or_MinArity = -1, int MaxArity = -1 >
+    class forward_adapter;
+
+    //----- ---- --- -- - -  -   -
+
+    namespace detail
+    {
+        template< class MostDerived, typename Function, typename FunctionConst, 
+            int Arity, int MinArity >
+        struct forward_adapter_impl;
+
+        struct forward_adapter_result
+        {
+            template< typename Sig > struct apply;
+
+            // Utility metafunction for qualification adjustment on arguments
+            template< typename T > struct q          { typedef T const t; };
+            template< typename T > struct q<T const> { typedef T const t; };
+            template< typename T > struct q<T &>     { typedef T       t; };
+
+            // Utility metafunction to choose target function qualification
+            template< typename T > struct c
+            { typedef typename T::target_function_t t; };
+            template< typename T > struct c<T&      >
+            { typedef typename T::target_function_t t; };
+            template< typename T > struct c<T const >
+            { typedef typename T::target_function_const_t t; };
+            template< typename T > struct c<T const&>
+            { typedef typename T::target_function_const_t t; };
+        };
+    }
+
+#   define BOOST_TMP_MACRO(f,fn,fc) \
+        boost::detail::forward_adapter_impl< \
+            forward_adapter<f,Arity_Or_MinArity,MaxArity>, fn, fc, \
+            (MaxArity!=-1? MaxArity :Arity_Or_MinArity!=-1? Arity_Or_MinArity \
+                :BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY), \
+            (Arity_Or_MinArity!=-1? Arity_Or_MinArity : 0) >
+
+    template< typename Function, int Arity_Or_MinArity, int MaxArity >
+    class forward_adapter
+        : public BOOST_TMP_MACRO(Function,Function,Function const)
+        , private Function
+    {
+      public:
+        forward_adapter(Function const& f = Function()) 
+          : Function(f) 
+        { }
+
+        typedef Function        target_function_t;
+        typedef Function const  target_function_const_t;
+
+        Function       & target_function()       { return *this; }
+        Function const & target_function() const { return *this; }
+
+        template< typename Sig > struct result
+            : detail::forward_adapter_result::template apply<Sig>
+        { };
+
+        using BOOST_TMP_MACRO(Function,Function, Function const)::operator();
+    };
+    template< typename Function, int Arity_Or_MinArity, int MaxArity >
+    class forward_adapter< Function const, Arity_Or_MinArity, MaxArity >
+        : public BOOST_TMP_MACRO(Function const, Function const, Function const)
+        , private Function
+    {
+      public:
+        forward_adapter(Function const& f = Function())
+          : Function(f) 
+        { }
+
+        typedef Function const target_function_t;
+        typedef Function const target_function_const_t;
+
+        Function const & target_function() const { return *this; }
+
+        template< typename Sig > struct result
+            : detail::forward_adapter_result::template apply<Sig>
+        { };
+
+        using BOOST_TMP_MACRO(Function const,Function const, Function const)
+            ::operator();
+    };
+    template< typename Function, int Arity_Or_MinArity, int MaxArity >
+    class forward_adapter< Function &, Arity_Or_MinArity, MaxArity >
+        : public BOOST_TMP_MACRO(Function&, Function, Function)
+    {
+        Function& ref_function;
+      public:
+        forward_adapter(Function& f)
+          : ref_function(f) 
+        { }
+
+        typedef Function target_function_t;
+        typedef Function target_function_const_t;
+
+        Function & target_function() const { return this->ref_function; }
+
+        template< typename Sig > struct result
+            : detail::forward_adapter_result::template apply<Sig>
+        { };
+
+        using BOOST_TMP_MACRO(Function&, Function, Function)::operator();
+    }; 
+
+    #undef BOOST_TMP_MACRO
+
+    namespace detail
+    {
+        template< class Self >
+        struct forward_adapter_result::apply< Self() >
+            : boost::result_of< BOOST_DEDUCED_TYPENAME c<Self>::t() >
+        { };
+
+        // WHen operator()() doesn't have any parameters, it can't
+        // be templatized and can't use SFINAE, so intead use class
+        // template parameter SFINAE to decide whether to instantiate it.
+
+        template <typename T, typename R = void>
+        struct forward_adapter_sfinae
+        {
+            typedef T type;
+        };
+
+        // This is the fallback for when there isn't an operator()(),
+        // need to create an operator() that will never instantiate
+        // so that using parent::operator() will work okay.
+        template< class MD, class F, class FC, class Enable = void>
+        struct forward_adapter_impl_zero
+        {
+            template <typename T> struct never_instantiate {};
+            template <typename T>
+            typename never_instantiate<T>::type operator()(T) const {}
+        };
+
+        template< class MD, class F, class FC>
+        struct forward_adapter_impl_zero<MD, F, FC,
+            typename forward_adapter_sfinae<typename boost::result_of< FC() >::type>::type>
+        {
+            inline typename boost::result_of< FC() >::type
+            operator()() const
+            {
+                return static_cast<MD const*>(this)->target_function()();
+            }
+
+            inline typename boost::result_of< F() >::type
+            operator()()
+            {
+                return static_cast<MD*>(this)->target_function()();
+            }
+        };
+
+        template< class MD, class F, class FC >
+        struct forward_adapter_impl<MD,F,FC,0,0>
+            : forward_adapter_impl_zero<MD,F,FC>
+        {
+            using forward_adapter_impl_zero<MD,F,FC>::operator();
+
+        // closing brace gets generated by preprocessing code, below
+
+#       define BOOST_TMP_MACRO(tpl_params,arg_types,params,args)              \
+            template< tpl_params >                                             \
+            inline typename boost::result_of< FC(arg_types) >::type            \
+            operator()(params) const                                           \
+            {                                                                  \
+                return static_cast<MD const*>(this)->target_function()(args);  \
+            }                                                                  \
+            template< tpl_params >                                             \
+            inline typename boost::result_of< F(arg_types)>::type              \
+            operator()(params)                                                 \
+            {                                                                  \
+                return static_cast<MD*>(this)->target_function()(args);        \
+            }
+
+#       // This is the total number of iterations we need
+#       define count ((1 << BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY+1)-2)
+
+#       // Chain file iteration to virtually one loop
+#       if BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY <= 7
+#         define limit1 count
+#         define limit2 0
+#         define limit3 0
+#       else
+#         if BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY <= 15
+#           define limit1 (count >> 8)
+#           define limit2 255
+#           define limit3 0
+#         else
+#           define limit1 (count >> 16)
+#           define limit2 255
+#           define limit3 255
+#         endif
+#       endif
+
+#       define N 0
+
+#       define  BOOST_PP_FILENAME_1 <boost/functional/forward_adapter.hpp>
+#       define  BOOST_PP_ITERATION_LIMITS (0,limit1)
+#       include BOOST_PP_ITERATE()
+
+#       undef N
+#       undef limit3
+#       undef limit2
+#       undef limit1
+#       undef count
+#       undef BOOST_TMP_MACRO
+
+        };
+
+    } // namespace detail
+
+    template<class F, int A0, int A1>
+    struct result_of<boost::forward_adapter<F,A0,A1> const ()>
+        : boost::detail::forward_adapter_result::template apply<
+            boost::forward_adapter<F,A0,A1> const () >
+    { };
+    template<class F, int A0, int A1>
+    struct result_of<boost::forward_adapter<F,A0,A1>()>
+        : boost::detail::forward_adapter_result::template apply<
+            boost::forward_adapter<F,A0,A1>() >
+    { };
+    template<class F, int A0, int A1>
+    struct result_of<boost::forward_adapter<F,A0,A1> const& ()>
+        : boost::detail::forward_adapter_result::template apply<
+            boost::forward_adapter<F,A0,A1> const () >
+    { };
+    template<class F, int A0, int A1>
+    struct result_of<boost::forward_adapter<F,A0,A1>& ()>
+        : boost::detail::forward_adapter_result::template apply<
+            boost::forward_adapter<F,A0,A1>() >
+    { };
+}
+
+#       define BOOST_FUNCTIONAL_FORWARD_ADAPTER_HPP_INCLUDED
+
+#   elif BOOST_PP_ITERATION_DEPTH() == 1 && limit2
+#     define  BOOST_PP_FILENAME_2 <boost/functional/forward_adapter.hpp>
+#     define  BOOST_PP_ITERATION_LIMITS (0,limit2)
+#     include BOOST_PP_ITERATE()
+#   elif BOOST_PP_ITERATION_DEPTH() == 2 && limit3
+#     define  BOOST_PP_FILENAME_3 <boost/functional/forward_adapter.hpp>
+#     define  BOOST_PP_ITERATION_LIMITS (0,limit3)
+#     include BOOST_PP_ITERATE()
+
+#   else
+
+#     // I is the loop counter
+#     if limit2 && limit3
+#       define I (BOOST_PP_ITERATION_1 << 16 | BOOST_PP_ITERATION_2 << 8 | \
+            BOOST_PP_ITERATION_3)
+#     elif limit2
+#       define I (BOOST_PP_ITERATION_1 << 8 | BOOST_PP_ITERATION_2)
+#     else
+#       define I BOOST_PP_ITERATION_1
+#     endif
+
+#     if I < count
+
+#       // Done for this arity? Increment N
+#       if (I+2 >> N+1) 
+#         if N == 0
+#           undef N
+#           define N 1
+#         elif N == 1
+#           undef N
+#           define N 2
+#         elif N == 2
+#           undef N
+#           define N 3
+#         elif N == 3
+#           undef N
+#           define N 4
+#         elif N == 4
+#           undef N
+#           define N 5
+#         elif N == 5
+#           undef N
+#           define N 6
+#         elif N == 6
+#           undef N
+#           define N 7
+#         elif N == 7
+#           undef N
+#           define N 8
+#         elif N == 8
+#           undef N
+#           define N 9
+#         elif N == 9
+#           undef N
+#           define N 10
+#         elif N == 10
+#           undef N
+#           define N 11
+#         elif N == 11
+#           undef N
+#           define N 12
+#         elif N == 12
+#           undef N
+#           define N 13
+#         elif N == 13
+#           undef N
+#           define N 14
+#         elif N == 14
+#           undef N
+#           define N 15
+#         elif N == 15
+#           undef N
+#           define N 16
+#         endif
+
+        };
+
+        template< class Self, BOOST_PP_ENUM_PARAMS(N,typename T) >
+        struct forward_adapter_result::apply< Self(BOOST_PP_ENUM_PARAMS(N,T)) >
+            : boost::result_of< 
+                BOOST_DEDUCED_TYPENAME c<Self>::t(BOOST_PP_ENUM_BINARY_PARAMS(N, 
+                      typename q<T,>::t& BOOST_PP_INTERCEPT)) >
+        { };
+
+        template< class MD, class F, class FC >
+        struct forward_adapter_impl<MD,F,FC,BOOST_PP_DEC(N),N>
+        {
+            template< BOOST_PP_ENUM_PARAMS(N,typename T) >
+            inline typename boost::result_of< F(
+                BOOST_PP_ENUM_BINARY_PARAMS(N,T,& BOOST_PP_INTERCEPT)) >::type
+            operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,T,& BOOST_PP_INTERCEPT));
+        };
+
+        template< class MD, class F, class FC, int MinArity >
+        struct forward_adapter_impl<MD,F,FC,N,MinArity>
+            : forward_adapter_impl<MD,F,FC,BOOST_PP_DEC(N),MinArity>
+        {
+            using forward_adapter_impl<MD,F,FC,BOOST_PP_DEC(N),MinArity>::operator();
+
+#       endif
+
+#       // Zero based count for each arity would be I-(1<<N)+2, but we don't
+#       // need it, unless we need a nicer order.
+
+#       // Macros for the parameter's type modifiers.
+#       if I & 0x000001
+#         define PT0 T0 &
+#       else
+#         define PT0 T0 const &
+#       endif
+#       if I & 0x000002
+#         define PT1 T1 &
+#       else
+#         define PT1 T1 const &
+#       endif
+#       if I & 0x000004
+#         define PT2 T2 &
+#       else
+#         define PT2 T2 const &
+#       endif
+#       if I & 0x000008
+#         define PT3 T3 &
+#       else
+#         define PT3 T3 const &
+#       endif
+#       if I & 0x000010
+#         define PT4 T4 &
+#       else
+#         define PT4 T4 const &
+#       endif
+#       if I & 0x000020
+#         define PT5 T5 &
+#       else
+#         define PT5 T5 const &
+#       endif
+#       if I & 0x000040
+#         define PT6 T6 &
+#       else
+#         define PT6 T6 const &
+#       endif
+#       if I & 0x000080
+#         define PT7 T7 &
+#       else
+#         define PT7 T7 const &
+#       endif
+#       if I & 0x000100
+#         define PT8 T8 &
+#       else
+#         define PT8 T8 const &
+#       endif
+#       if I & 0x000200
+#         define PT9 T9 &
+#       else
+#         define PT9 T9 const &
+#       endif
+#       if I & 0x000400
+#         define PT10 T10 &
+#       else
+#         define PT10 T10 const &
+#       endif
+#       if I & 0x000800
+#         define PT11 T11 &
+#       else
+#         define PT11 T11 const &
+#       endif
+#       if I & 0x001000
+#         define PT12 T12 &
+#       else
+#         define PT12 T12 const &
+#       endif
+#       if I & 0x002000
+#         define PT13 T13 &
+#       else
+#         define PT13 T13 const &
+#       endif
+#       if I & 0x004000
+#         define PT14 T14 &
+#       else
+#         define PT14 T14 const &
+#       endif
+#       if I & 0x008000
+#         define PT15 T15 &
+#       else
+#         define PT15 T15 const &
+#       endif
+
+#       if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1400)) 
+            template< BOOST_PP_ENUM_PARAMS(N,typename T) >
+            inline typename boost::result_of<  FC(BOOST_PP_ENUM_PARAMS(N,PT)) 
+                >::type
+            operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,PT,a)) const
+            {
+                return static_cast<MD const* const>(this)
+                    ->target_function()(BOOST_PP_ENUM_PARAMS(N,a));
+            }
+            template< BOOST_PP_ENUM_PARAMS(N,typename T) >
+            inline typename boost::result_of<  F(BOOST_PP_ENUM_PARAMS(N,PT))
+                >::type
+            operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,PT,a))
+            {
+                return static_cast<MD* const>(this)
+                    ->target_function()(BOOST_PP_ENUM_PARAMS(N,a));
+            }
+#       else
+        BOOST_TMP_MACRO(BOOST_PP_ENUM_PARAMS(N,typename T),
+            BOOST_PP_ENUM_PARAMS(N,PT), BOOST_PP_ENUM_BINARY_PARAMS(N,PT,a),
+            BOOST_PP_ENUM_PARAMS(N,a) )
+        // ...generates uglier code but is faster - it caches ENUM_*
+#       endif
+
+#       undef PT0
+#       undef PT1
+#       undef PT2
+#       undef PT3
+#       undef PT4
+#       undef PT5
+#       undef PT6
+#       undef PT7
+#       undef PT8
+#       undef PT9
+#       undef PT10
+#       undef PT11
+#       undef PT12
+#       undef PT13
+#       undef PT14
+#       undef PT15
+
+#     endif // I < count
+
+#     undef I
+#   endif // defined(BOOST_PP_IS_ITERATING)
+
+#endif // include guard
+
diff --git a/include/boost/functional/lightweight_forward_adapter.hpp b/include/boost/functional/lightweight_forward_adapter.hpp
new file mode 100644
index 0000000..4c0d864
--- /dev/null
+++ b/include/boost/functional/lightweight_forward_adapter.hpp
@@ -0,0 +1,288 @@
+/*=============================================================================
+    Copyright (c) 2007 Tobias Schwinger
+  
+    Use modification and distribution are subject to the Boost Software 
+    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+==============================================================================*/
+
+#ifndef BOOST_FUNCTIONAL_LIGHTWEIGHT_FORWARD_ADAPTER_HPP_INCLUDED
+#   ifndef BOOST_PP_IS_ITERATING
+
+#   include <boost/config.hpp>
+#   include <boost/config/workaround.hpp>
+
+#   include <boost/preprocessor/cat.hpp>
+#   include <boost/preprocessor/iteration/iterate.hpp>
+#   include <boost/preprocessor/repetition/enum.hpp>
+#   include <boost/preprocessor/repetition/enum_params.hpp>
+#   include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#   include <boost/preprocessor/facilities/intercept.hpp>
+
+#   include <boost/utility/result_of.hpp>
+#   include <boost/ref.hpp>
+
+#   ifndef BOOST_FUNCTIONAL_LIGHTWEIGHT_FORWARD_ADAPTER_MAX_ARITY
+#     define BOOST_FUNCTIONAL_LIGHTWEIGHT_FORWARD_ADAPTER_MAX_ARITY 10
+#   elif BOOST_FUNCTIONAL_FORDWARD_ADAPTER_MAX_ARITY < 3
+#     undef  BOOST_FUNCTIONAL_LIGHTWEIGHT_FORWARD_ADAPTER_MAX_ARITY
+#     define BOOST_FUNCTIONAL_LIGHTWEIGHT_FORWARD_ADAPTER_MAX_ARITY 3
+#   endif
+
+namespace boost 
+{
+    template< typename Function, int Arity_Or_MinArity = -1, int MaxArity = -1 >
+    class lightweight_forward_adapter;
+
+    //----- ---- --- -- - -  -   -
+
+    namespace detail
+    {
+        template< class MostDerived, typename Function, typename FunctionConst, 
+            int Arity, int MinArity >
+        struct lightweight_forward_adapter_impl;
+
+        struct lightweight_forward_adapter_result
+        {
+            template< typename Sig > struct apply;
+
+            // Utility metafunction for argument transform
+            template< typename T > struct x  { typedef T const& t; };
+            template< typename T > struct x< boost::reference_wrapper<T> >
+            { typedef T& t; };
+            template< typename T > struct x<T&>       : x<T> { };
+            template< typename T > struct x<T const&> : x<T> { };
+            template< typename T > struct x<T const>  : x<T> { };
+
+            // Utility metafunction to choose target function qualification
+            template< typename T > struct c
+            { typedef typename T::target_function_t t; };
+            template< typename T > struct c<T&      >
+            { typedef typename T::target_function_t t; };
+            template< typename T > struct c<T const >
+            { typedef typename T::target_function_const_t t; };
+            template< typename T > struct c<T const&>
+            { typedef typename T::target_function_const_t t; };
+        };
+    }
+
+#   define BOOST_TMP_MACRO(f,fn,fc) \
+        boost::detail::lightweight_forward_adapter_impl< \
+            lightweight_forward_adapter<f,Arity_Or_MinArity,MaxArity>, fn, fc, \
+            (MaxArity!=-1? MaxArity :Arity_Or_MinArity!=-1? Arity_Or_MinArity \
+                :BOOST_FUNCTIONAL_LIGHTWEIGHT_FORWARD_ADAPTER_MAX_ARITY), \
+            (Arity_Or_MinArity!=-1? Arity_Or_MinArity : 0) >
+
+    template< typename Function, int Arity_Or_MinArity, int MaxArity >
+    class lightweight_forward_adapter
+        : public BOOST_TMP_MACRO(Function,Function,Function const)
+        , private Function
+    {
+      public:
+        lightweight_forward_adapter(Function const& f = Function()) 
+          : Function(f) 
+        { }
+
+        typedef Function        target_function_t;
+        typedef Function const  target_function_const_t;
+
+        Function       & target_function()       { return *this; }
+        Function const & target_function() const { return *this; }
+
+        template< typename Sig > struct result
+            : detail::lightweight_forward_adapter_result::template apply<Sig>
+        { };
+
+        using BOOST_TMP_MACRO(Function,Function, Function const)::operator();
+    };
+    template< typename Function, int Arity_Or_MinArity, int MaxArity >
+    class lightweight_forward_adapter< Function const, Arity_Or_MinArity, 
+        MaxArity >
+        : public BOOST_TMP_MACRO(Function const, Function const, Function const)
+        , private Function
+    {
+      public:
+        lightweight_forward_adapter(Function const& f = Function())
+          : Function(f) 
+        { }
+
+        typedef Function const target_function_t;
+        typedef Function const target_function_const_t;
+
+        Function const & target_function() const { return *this; }
+
+        template< typename Sig > struct result
+            : detail::lightweight_forward_adapter_result::template apply<Sig>
+        { };
+
+        using BOOST_TMP_MACRO(Function const,Function const, Function const)
+            ::operator();
+    };
+    template< typename Function, int Arity_Or_MinArity, int MaxArity >
+    class lightweight_forward_adapter< Function &, Arity_Or_MinArity, MaxArity >
+        : public BOOST_TMP_MACRO(Function&, Function, Function)
+    {
+        Function& ref_function;
+      public:
+        lightweight_forward_adapter(Function& f)
+          : ref_function(f) 
+        { }
+
+        typedef Function target_function_t;
+        typedef Function target_function_const_t;
+
+        Function & target_function() const { return this->ref_function; }
+
+        template< typename Sig > struct result
+            : detail::lightweight_forward_adapter_result::template apply<Sig>
+        { };
+
+        using BOOST_TMP_MACRO(Function&, Function, Function)::operator();
+    }; 
+
+    #undef BOOST_TMP_MACRO
+
+    namespace detail
+    {
+        template< class Self >
+        struct lightweight_forward_adapter_result::apply< Self() >
+            : boost::result_of< BOOST_DEDUCED_TYPENAME c<Self>::t() >
+        { };
+
+        // When operator() doesn't have any parameters, it can't
+        // be templatized and can't use SFINAE, so intead use class
+        // template parameter SFINAE to decide whether to instantiate it.
+
+        template <typename T, typename R = void>
+        struct lightweight_forward_adapter_sfinae
+        {
+            typedef T type;
+        };
+
+        // This is the fallback for when there isn't an operator()(),
+        // need to create an operator() that will never instantiate
+        // so that using parent::operator() will work okay.
+        template< class MD, class F, class FC, class Enable = void>
+        struct lightweight_forward_adapter_impl_zero
+            : lightweight_forward_adapter_result
+        {
+            template <typename T> struct never_instantiate {};
+            template <typename T>
+            typename never_instantiate<T>::type operator()(T) const {}
+        };
+
+        template< class MD, class F, class FC>
+        struct lightweight_forward_adapter_impl_zero<MD, F, FC,
+            typename lightweight_forward_adapter_sfinae<typename boost::result_of< FC() >::type>::type>
+            : lightweight_forward_adapter_result
+        {
+            inline typename boost::result_of< FC() >::type
+            operator()() const
+            {
+                return static_cast<MD const*>(this)->target_function()();
+            }
+
+            inline typename boost::result_of< F() >::type
+            operator()()
+            {
+                return static_cast<MD*>(this)->target_function()();
+            }
+        };
+
+        template< class MD, class F, class FC >
+        struct lightweight_forward_adapter_impl<MD,F,FC,0,0>
+            : lightweight_forward_adapter_impl_zero<MD,F,FC>
+        {
+        };
+
+#       define  BOOST_PP_FILENAME_1 \
+            <boost/functional/lightweight_forward_adapter.hpp>
+#       define  BOOST_PP_ITERATION_LIMITS                                     \
+            (1,BOOST_FUNCTIONAL_LIGHTWEIGHT_FORWARD_ADAPTER_MAX_ARITY) 
+#       include BOOST_PP_ITERATE()
+
+    } // namespace detail
+
+    template<class F, int A0, int A1>
+    struct result_of<boost::lightweight_forward_adapter<F,A0,A1> const ()>
+        : boost::detail::lightweight_forward_adapter_result::template apply<
+            boost::lightweight_forward_adapter<F,A0,A1> const () >
+    { };
+    template<class F, int A0, int A1>
+    struct result_of<boost::lightweight_forward_adapter<F,A0,A1>()>
+        : boost::detail::lightweight_forward_adapter_result::template apply<
+            boost::lightweight_forward_adapter<F,A0,A1>() >
+    { };
+    template<class F, int A0, int A1>
+    struct result_of<boost::lightweight_forward_adapter<F,A0,A1> const& ()>
+        : boost::detail::lightweight_forward_adapter_result::template apply<
+            boost::lightweight_forward_adapter<F,A0,A1> const () >
+    { };
+    template<class F, int A0, int A1>
+    struct result_of<boost::lightweight_forward_adapter<F,A0,A1>& ()>
+        : boost::detail::lightweight_forward_adapter_result::template apply<
+            boost::lightweight_forward_adapter<F,A0,A1>() >
+    { };
+}
+
+#     define BOOST_FUNCTIONAL_LIGHTWEIGHT_FORWARD_ADAPTER_HPP_INCLUDED
+
+#   else // defined(BOOST_PP_IS_ITERATING)
+#     define N BOOST_PP_ITERATION() 
+
+        template< class Self, BOOST_PP_ENUM_PARAMS(N,typename T) >
+        struct lightweight_forward_adapter_result::apply<
+            Self (BOOST_PP_ENUM_PARAMS(N,T)) >
+            : boost::result_of<
+                BOOST_DEDUCED_TYPENAME c<Self>::t (BOOST_PP_ENUM_BINARY_PARAMS(N,
+                    typename x<T,>::t BOOST_PP_INTERCEPT)) >
+        { };
+
+        template< class MD, class F, class FC >
+        struct lightweight_forward_adapter_impl<MD,F,FC,BOOST_PP_DEC(N),N>
+            : lightweight_forward_adapter_result
+        {
+            template< BOOST_PP_ENUM_PARAMS(N,typename T) >
+            inline typename boost::result_of< F(BOOST_PP_ENUM_BINARY_PARAMS(N,
+                T,const& BOOST_PP_INTERCEPT)) >::type
+            operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,T,& BOOST_PP_INTERCEPT));
+        };
+
+        template< class MD, class F, class FC, int MinArity >
+        struct lightweight_forward_adapter_impl<MD,F,FC,N,MinArity>
+            : lightweight_forward_adapter_impl<MD,F,FC,BOOST_PP_DEC(N),MinArity>
+        {
+            using lightweight_forward_adapter_impl<MD,F,FC,BOOST_PP_DEC(N),
+                MinArity>::operator();
+
+#     define M(z,i,d) \
+          static_cast<typename d::template x<T##i>::t>(a##i)
+
+            template< BOOST_PP_ENUM_PARAMS(N,typename T) >
+            inline typename lightweight_forward_adapter_result::template apply<
+                MD const (BOOST_PP_ENUM_BINARY_PARAMS(N,
+                    T,const& BOOST_PP_INTERCEPT)) >::type
+            operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,T,const& a)) const
+            {
+                typedef lightweight_forward_adapter_result _;
+                return static_cast<MD const*>(this)->target_function()(
+                    BOOST_PP_ENUM(N,M,_));
+            }
+            template< BOOST_PP_ENUM_PARAMS(N,typename T) >
+            inline typename lightweight_forward_adapter_result::template apply<
+                MD (BOOST_PP_ENUM_BINARY_PARAMS(N,
+                    T,const& BOOST_PP_INTERCEPT)) >::type
+            operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,T,const& a))
+            {
+                typedef lightweight_forward_adapter_result _;
+                return static_cast<MD*>(this)->target_function()(
+                    BOOST_PP_ENUM(N,M,_));
+            }
+#     undef M
+      };
+
+#     undef N
+#   endif // defined(BOOST_PP_IS_ITERATING)
+
+#endif // include guard
+
diff --git a/include/boost/functional/overloaded_function.hpp b/include/boost/functional/overloaded_function.hpp
new file mode 100644
index 0000000..83fe4b3
--- /dev/null
+++ b/include/boost/functional/overloaded_function.hpp
@@ -0,0 +1,311 @@
+
+// Copyright (C) 2009-2012 Lorenzo Caminiti
+// Distributed under the Boost Software License, Version 1.0
+// (see accompanying file LICENSE_1_0.txt or a copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+// Home at http://www.boost.org/libs/functional/overloaded_function
+
+#ifndef DOXYGEN // Doxygen documentation only.
+
+#if !BOOST_PP_IS_ITERATING
+#   ifndef BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_HPP_
+#       define BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_HPP_
+
+#       include <boost/functional/overloaded_function/detail/base.hpp>
+#       include <boost/functional/overloaded_function/detail/function_type.hpp>
+#       include <boost/functional/overloaded_function/config.hpp>
+#       include <boost/typeof/typeof.hpp>
+#       include <boost/preprocessor/iteration/iterate.hpp>
+#       include <boost/preprocessor/repetition/enum.hpp>
+#       include <boost/preprocessor/repetition/repeat.hpp>
+#       include <boost/preprocessor/control/expr_iif.hpp>
+#       include <boost/preprocessor/control/expr_if.hpp>
+#       include <boost/preprocessor/comparison/greater.hpp>
+#       include <boost/preprocessor/comparison/less.hpp>
+#       include <boost/preprocessor/cat.hpp>
+#       include <boost/preprocessor/arithmetic/add.hpp>
+#       include <boost/preprocessor/arithmetic/sub.hpp>
+#       include <boost/preprocessor/tuple/eat.hpp>
+#       include <boost/preprocessor/logical/and.hpp>
+#       include <boost/preprocessor/logical/not.hpp>
+#       include <boost/preprocessor/facilities/expand.hpp>
+
+#define BOOST_FUNCTIONAL_f_type(z, n, unused) \
+    BOOST_PP_CAT(F, n)
+
+#define BOOST_FUNCTIONAL_f_arg(z, n, unused) \
+    BOOST_PP_CAT(f, n)
+
+#define BOOST_FUNCTIONAL_f_tparam(z, n, unused) \
+    typename BOOST_FUNCTIONAL_f_type(z, n, ~) \
+
+#define BOOST_FUNCTIONAL_f_tparam_dflt(z, n, is_tspec) \
+    BOOST_FUNCTIONAL_f_tparam(z, n, ~) \
+    /* overload requires at least 2 functors so F0 and F1 not optional */ \
+    BOOST_PP_EXPR_IIF(BOOST_PP_AND(BOOST_PP_NOT(is_tspec), \
+            BOOST_PP_GREATER(n, 1)), \
+        = void \
+    )
+
+#define BOOST_FUNCTIONAL_f_arg_decl(z, n, unused) \
+    BOOST_FUNCTIONAL_f_type(z, n, ~) /* no qualifier to deduce tparam */ \
+    BOOST_FUNCTIONAL_f_arg(z, n, ~)
+
+#define BOOST_FUNCTIONAL_g_type(z, n, unused) \
+    BOOST_PP_CAT(G, n)
+
+#define BOOST_FUNCTIONAL_g_arg(z, n, unused) \
+    BOOST_PP_CAT(g, n)
+
+#define BOOST_FUNCTIONAL_g_tparam(z, n, unused) \
+    typename BOOST_FUNCTIONAL_g_type(z, n, ~)
+
+#define BOOST_FUNCTIONAL_g_arg_decl(z, n, unused) \
+    BOOST_FUNCTIONAL_g_type(z, n, ~) /* no qualifier to deduce tparam */ \
+    BOOST_FUNCTIONAL_g_arg(z, n, ~)
+
+#define BOOST_FUNCTIONAL_base(z, n, unused) \
+    ::boost::overloaded_function_detail::base< \
+        BOOST_FUNCTIONAL_f_type(z, n, ~) \
+    >
+
+#define BOOST_FUNCTIONAL_inherit(z, n, unused) \
+    public BOOST_FUNCTIONAL_base(z, n, ~)
+
+#define BOOST_FUNCTIONAL_base_init(z, n, unused) \
+    BOOST_FUNCTIONAL_base(z, n, ~)(BOOST_FUNCTIONAL_g_arg(z, n, ~))
+
+#define BOOST_FUNCTIONAL_using_operator_call(z, n, unused) \
+    using BOOST_FUNCTIONAL_base(z, n, ~)::operator();
+
+#define BOOST_FUNCTIONAL_function_type(z, n, unused) \
+    typename ::boost::overloaded_function_detail::function_type< \
+        BOOST_FUNCTIONAL_f_type(z, n, ~) \
+    >::type
+
+#       define BOOST_PP_ITERATION_PARAMS_1 \
+            /* at least 2 func to overload so start from 2 to MAX */ \
+            /* (cannot iterate [0, MAX-2) because error on Sun) */ \
+            (3, (2, BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_CONFIG_OVERLOAD_MAX, \
+            "boost/functional/overloaded_function.hpp"))
+#       include BOOST_PP_ITERATE() // Iterate over function arity.
+
+#undef BOOST_FUNCTIONAL_f_type
+#undef BOOST_FUNCTIONAL_f_arg
+#undef BOOST_FUNCTIONAL_f_tparam
+#undef BOOST_FUNCTIONAL_f_arg_decl
+#undef BOOST_FUNCTIONAL_f_tparam_dflt
+#undef BOOST_FUNCTIONAL_g_type
+#undef BOOST_FUNCTIONAL_g_arg
+#undef BOOST_FUNCTIONAL_g_tparam
+#undef BOOST_FUNCTIONAL_g_arg_decl
+#undef BOOST_FUNCTIONAL_base
+#undef BOOST_FUNCTIONAL_inherit
+#undef BOOST_FUNCTIONAL_base_init
+#undef BOOST_FUNCTIONAL_using_operator_call
+#undef BOOST_FUNCTIONAL_function_type
+
+#   endif // #include guard
+
+#elif BOOST_PP_ITERATION_DEPTH() == 1
+#   define BOOST_FUNCTIONAL_overloads \
+        /* iterate as OVERLOADS, OVERLOADS-1, OVERLOADS-2, ... */ \
+        /* (add 2 because iteration started from 2 to MAX) */ \
+        BOOST_PP_ADD(2, BOOST_PP_SUB( \
+                BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_CONFIG_OVERLOAD_MAX, \
+                BOOST_PP_FRAME_ITERATION(1)))
+#   define BOOST_FUNCTIONAL_is_tspec \
+        /* if template specialization */ \
+        BOOST_PP_LESS(BOOST_FUNCTIONAL_overloads, \
+                BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_CONFIG_OVERLOAD_MAX)
+
+// For type-of emulation: This must be included at this pp iteration level.
+#   include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+namespace boost {
+
+template<
+    BOOST_PP_ENUM(BOOST_FUNCTIONAL_overloads, BOOST_FUNCTIONAL_f_tparam_dflt,
+            BOOST_FUNCTIONAL_is_tspec)
+>
+class overloaded_function
+    // Template specialization.
+    BOOST_PP_EXPR_IIF(BOOST_PP_EXPAND(BOOST_FUNCTIONAL_is_tspec), <)
+    BOOST_PP_IIF(BOOST_FUNCTIONAL_is_tspec,
+        BOOST_PP_ENUM
+    ,
+        BOOST_PP_TUPLE_EAT(3)
+    )(BOOST_FUNCTIONAL_overloads, BOOST_FUNCTIONAL_f_type, ~)
+    BOOST_PP_EXPR_IIF(BOOST_PP_EXPAND(BOOST_FUNCTIONAL_is_tspec), >)
+    // Bases (overloads >= 2 so always at least 2 bases).
+    : BOOST_PP_ENUM(BOOST_FUNCTIONAL_overloads,
+            BOOST_FUNCTIONAL_inherit, ~)
+{
+public:
+    template<
+        BOOST_PP_ENUM(BOOST_FUNCTIONAL_overloads, BOOST_FUNCTIONAL_g_tparam, ~)
+    > /* implicit */ inline overloaded_function(
+            BOOST_PP_ENUM(BOOST_FUNCTIONAL_overloads,
+                    BOOST_FUNCTIONAL_g_arg_decl, ~))
+            // Overloads >= 2 so always at least 2 bases to initialize.
+            : BOOST_PP_ENUM(BOOST_FUNCTIONAL_overloads,
+                    BOOST_FUNCTIONAL_base_init, ~)
+    {}
+
+    BOOST_PP_REPEAT(BOOST_FUNCTIONAL_overloads, 
+            BOOST_FUNCTIONAL_using_operator_call, ~)
+};
+
+template<
+    BOOST_PP_ENUM(BOOST_FUNCTIONAL_overloads, BOOST_FUNCTIONAL_f_tparam, ~)
+>
+overloaded_function<
+    BOOST_PP_ENUM(BOOST_FUNCTIONAL_overloads, BOOST_FUNCTIONAL_function_type, ~)
+> make_overloaded_function(
+    BOOST_PP_ENUM(BOOST_FUNCTIONAL_overloads, BOOST_FUNCTIONAL_f_arg_decl, ~)
+) {
+    return overloaded_function<
+        BOOST_PP_ENUM(BOOST_FUNCTIONAL_overloads,
+                BOOST_FUNCTIONAL_function_type, ~)
+    >(BOOST_PP_ENUM(BOOST_FUNCTIONAL_overloads, BOOST_FUNCTIONAL_f_arg, ~));
+}
+
+} // namespace
+
+// For type-of emulation: Register overloaded function type (for _AUTO, etc).
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::overloaded_function,
+    BOOST_FUNCTIONAL_overloads)
+
+#   undef BOOST_FUNCTIONAL_overloads
+#   undef BOOST_FUNCTIONAL_is_tspec
+#endif // iteration
+
+// DOCUMENTATION //
+
+#else // DOXYGEN
+
+/** @file
+@brief Overload distinct function pointers, function references, and
+monomorphic function objects into a single function object.
+*/
+
+namespace boost {
+
+/**
+@brief Function object to overload functions with distinct signatures.
+
+This function object aggregates together calls to functions of all the
+specified function types <c>F1</c>, <c>F2</c>, etc which must have distinct
+function signatures from one another.
+
+@Params
+@Param{F<em>i</em>,
+Each function type must be specified using the following syntax (which is
+Boost.Function's preferred syntax):
+@code
+    result_type (argument1_type\, argumgnet2_type\, ...)
+@endcode
+}
+@EndParams
+
+In some cases, the @RefFunc{make_overloaded_function} function template can be
+useful to construct an overloaded function object without explicitly
+specifying the function types.
+
+At least two distinct function types must be specified (because there is
+nothing to overload between one or zero functions).
+The maximum number of functions to overload is given by the
+@RefMacro{BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_CONFIG_OVERLOAD_MAX}
+configuration macro.
+The maximum number of function parameters for each of the specified function
+types is given by the
+@RefMacro{BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_CONFIG_ARITY_MAX}
+configuration macro.
+
+@See @RefSect{tutorial, Tutorial} section, @RefFunc{make_overloaded_function},
+@RefMacro{BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_CONFIG_OVERLOAD_MAX},
+@RefMacro{BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_CONFIG_ARITY_MAX},
+Boost.Function.
+*/
+template<typename F1, typename F2, ...>
+class overloaded_function {
+public:
+    /**
+    @brief Construct the overloaded function object.
+
+    Any function pointer, function reference, and monomorphic function object
+    that can be converted to a <c>boost::function</c> function object can be
+    specified as parameter.
+
+    @Note Unfortunately, it is not possible to support polymorphic function
+    objects (as explained <a
+    href="http://lists.boost.org/Archives/boost/2012/03/191744.php">here</a>).
+    */
+    overloaded_function(const boost::function<F1>&,
+            const boost::function<F2>&, ...);
+
+    /**
+    @brief Call operator matching the signature of the function type specified
+    as 1st template parameter.
+
+    This will in turn invoke the call operator of the 1st function passed to
+    the constructor.
+    */
+    typename boost::function_traits<F1>::result_type operator()(
+            typename boost::function_traits<F1>::arg1_type,
+            typename boost::function_traits<F1>::arg2_type,
+            ...) const;
+
+    /**
+    @brief Call operator matching the signature of the function type specified
+    as 2nd template parameter.
+
+    This will in turn invoke the call operator of the 2nd function passed to
+    the constructor.
+
+    @Note Similar call operators are present for all specified function types
+    <c>F1</c>, <c>F2</c>, etc (even if not exhaustively listed by this
+    documentation).
+    */
+    typename boost::function_traits<F2>::result_type operator()(
+            typename boost::function_traits<F2>::arg1_type,
+            typename boost::function_traits<F2>::arg2_type,
+            ...) const;
+};
+
+/**
+@brief Make an overloaded function object without explicitly specifying the
+function types.
+
+This function template creates and returns an @RefClass{overloaded_function}
+object that overloads all the specified functions <c>f1</c>, <c>f2</c>, etc.
+
+The function types are internally determined from the template parameter types
+so they do not need to be explicitly specified.
+Therefore, this function template usually has a more concise syntax when
+compared with @RefClass{overloaded_function}.
+This is especially useful when the explicit type of the returned
+@RefClass{overloaded_function} object does not need to be known (e.g., when
+used with Boost.Typeof's <c>BOOST_AUTO</c>, C++11 <c>auto</c>, or when the
+overloaded function object is handled using a function template parameter, see
+the @RefSect{tutorial, Tutorial} section).
+
+The maximum number of functions to overload is given by the
+@RefMacro{BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_CONFIG_OVERLOAD_MAX}
+configuration macro.
+
+@Note In this documentation, <c>__function_type__</c> is a placeholder for a
+symbol that is specific to the implementation of this library.
+
+@See @RefSect{tutorial, Tutorial} section, @RefClass{overloaded_function},
+@RefMacro{BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_CONFIG_OVERLOAD_MAX}.
+*/
+template<typename F1, typename F2, ...>
+overloaded_function<
+    __function_type__<F1>, __function_type__<F2>, ...
+> make_overloaded_function(F1 f1, F2 f2, ...);
+
+} // namespace
+
+#endif // DOXYGEN
+
diff --git a/include/boost/functional/overloaded_function/config.hpp b/include/boost/functional/overloaded_function/config.hpp
new file mode 100644
index 0000000..2f5d9e1
--- /dev/null
+++ b/include/boost/functional/overloaded_function/config.hpp
@@ -0,0 +1,50 @@
+
+// Copyright (C) 2009-2012 Lorenzo Caminiti
+// Distributed under the Boost Software License, Version 1.0
+// (see accompanying file LICENSE_1_0.txt or a copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+// Home at http://www.boost.org/libs/functional/overloaded_function
+
+#ifndef BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_CONFIG_HPP_
+#define BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_CONFIG_HPP_
+
+/** @file
+@brief Change the compile-time configuration of this library.
+*/
+
+/**
+@brief Specify the maximum number of arguments of the functions being
+overloaded.
+
+If this macro is left undefined by the user, it has a default value of 5
+(increasing this number might increase compilation time).
+When specified by the user, this macro must be a non-negative integer number.
+
+@See @RefSect{getting_started, Getting Started},
+@RefClass{boost::overloaded_function}.
+*/
+#ifndef BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_CONFIG_ARITY_MAX 
+#   define BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_CONFIG_ARITY_MAX 5
+#endif
+
+/**
+@brief Specify the maximum number of functions that can be overloaded.
+
+If this macro is left undefined by the user, it has a default value of 5
+(increasing this number might increase compilation time).
+When defined by the user, this macro must be an integer number greater or
+equal than 2 (because at least two distinct functions need to be specified in
+order to define an overload).
+
+@See @RefSect{getting_started, Getting Started},
+@RefClass{boost::overloaded_function}.
+*/
+#ifndef BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_CONFIG_OVERLOAD_MAX
+#   define BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_CONFIG_OVERLOAD_MAX 5
+#endif
+#if BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_CONFIG_OVERLOAD_MAX < 2
+#   error "maximum overload macro cannot be less than 2"
+#endif
+
+#endif // #include guard
+
diff --git a/include/boost/functional/overloaded_function/detail/base.hpp b/include/boost/functional/overloaded_function/detail/base.hpp
new file mode 100644
index 0000000..8fd9a0a
--- /dev/null
+++ b/include/boost/functional/overloaded_function/detail/base.hpp
@@ -0,0 +1,86 @@
+
+// Copyright (C) 2009-2012 Lorenzo Caminiti
+// Distributed under the Boost Software License, Version 1.0
+// (see accompanying file LICENSE_1_0.txt or a copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+// Home at http://www.boost.org/libs/functional/overloaded_function
+
+#if !BOOST_PP_IS_ITERATING
+#   ifndef BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_DETAIL_BASE_HPP_
+#       define BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_DETAIL_BASE_HPP_
+
+#       include <boost/functional/overloaded_function/config.hpp>
+#       include <boost/function.hpp>
+#       include <boost/preprocessor/iteration/iterate.hpp>
+#       include <boost/preprocessor/repetition/enum.hpp>
+#       include <boost/preprocessor/cat.hpp>
+#       include <boost/preprocessor/comma_if.hpp>
+
+#define BOOST_FUNCTIONAL_DETAIL_arg_type(z, n, unused) \
+    BOOST_PP_CAT(A, n)
+
+#define BOOST_FUNCTIONAL_DETAIL_arg_name(z, n, unused) \
+    BOOST_PP_CAT(a, n)
+
+#define BOOST_FUNCTIONAL_DETAIL_arg_tparam(z, n, unused) \
+    typename BOOST_FUNCTIONAL_DETAIL_arg_type(z, n, unused)
+
+#define BOOST_FUNCTIONAL_DETAIL_arg(z, n, unused) \
+    BOOST_FUNCTIONAL_DETAIL_arg_type(z, n, unused) \
+    BOOST_FUNCTIONAL_DETAIL_arg_name(z, n, unused)
+
+#define BOOST_FUNCTIONAL_DETAIL_f \
+    R (BOOST_PP_ENUM(BOOST_FUNCTIONAL_DETAIL_arity, \
+            BOOST_FUNCTIONAL_DETAIL_arg_type, ~))
+
+// Do not use namespace ::detail because overloaded_function is already a class.
+namespace boost { namespace overloaded_function_detail {
+
+template<typename F>
+class base {}; // Empty template cannot be used directly (only its spec).
+
+#       define BOOST_PP_ITERATION_PARAMS_1 \
+                (3, (0, BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_CONFIG_ARITY_MAX, \
+                "boost/functional/overloaded_function/detail/base.hpp"))
+#       include BOOST_PP_ITERATE() // Iterate over funciton arity.
+
+} } // namespace
+
+#undef BOOST_FUNCTIONAL_DETAIL_arg_type
+#undef BOOST_FUNCTIONAL_DETAIL_arg_name
+#undef BOOST_FUNCTIONAL_DETAIL_arg_tparam
+#undef BOOST_FUNCTIONAL_DETAIL_arg
+#undef BOOST_FUNCTIONAL_DETAIL_f
+
+#   endif // #include guard
+
+#elif BOOST_PP_ITERATION_DEPTH() == 1
+#   define BOOST_FUNCTIONAL_DETAIL_arity BOOST_PP_FRAME_ITERATION(1)
+
+template<
+    typename R
+    BOOST_PP_COMMA_IF(BOOST_FUNCTIONAL_DETAIL_arity)
+    BOOST_PP_ENUM(BOOST_FUNCTIONAL_DETAIL_arity,
+            BOOST_FUNCTIONAL_DETAIL_arg_tparam, ~)
+>
+class base< BOOST_FUNCTIONAL_DETAIL_f > {
+public:
+    /* implicit */ inline base(
+            // This requires specified type to be implicitly convertible to
+            // a boost::function<> functor.
+            boost::function< BOOST_FUNCTIONAL_DETAIL_f > const& f): f_(f)
+    {}
+
+    inline R operator()(BOOST_PP_ENUM(BOOST_FUNCTIONAL_DETAIL_arity,
+            BOOST_FUNCTIONAL_DETAIL_arg, ~)) const {
+        return f_(BOOST_PP_ENUM(BOOST_FUNCTIONAL_DETAIL_arity,
+                BOOST_FUNCTIONAL_DETAIL_arg_name, ~));
+    }
+
+private:
+    boost::function< BOOST_FUNCTIONAL_DETAIL_f > const f_;
+};
+
+#   undef BOOST_FUNCTIONAL_DETAIL_arity
+#endif // iteration
+
diff --git a/include/boost/functional/overloaded_function/detail/function_type.hpp b/include/boost/functional/overloaded_function/detail/function_type.hpp
new file mode 100644
index 0000000..0c28607
--- /dev/null
+++ b/include/boost/functional/overloaded_function/detail/function_type.hpp
@@ -0,0 +1,85 @@
+
+// Copyright (C) 2009-2012 Lorenzo Caminiti
+// Distributed under the Boost Software License, Version 1.0
+// (see accompanying file LICENSE_1_0.txt or a copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+// Home at http://www.boost.org/libs/functional/overloaded_function
+
+#ifndef BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_DETAIL_FUNCTION_TYPE_HPP_
+#define BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_DETAIL_FUNCTION_TYPE_HPP_
+
+#include <boost/function_types/is_function.hpp>
+#include <boost/function_types/is_function_pointer.hpp>
+#include <boost/function_types/is_function_reference.hpp>
+#include <boost/function_types/function_type.hpp>
+#include <boost/function_types/parameter_types.hpp>
+#include <boost/function_types/result_type.hpp>
+#include <boost/type_traits/remove_pointer.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/function.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/pop_front.hpp>
+#include <boost/mpl/push_front.hpp>
+#include <boost/typeof/typeof.hpp>
+
+// Do not use namespace ::detail because overloaded_function is already a class.
+namespace boost { namespace overloaded_function_detail {
+
+// Requires: F is a monomorphic functor (i.e., has non-template `operator()`).
+// Returns: F's function type `result_type (arg1_type, arg2_type, ...)`.
+// It does not assume F typedef result_type, arg1_type, ... but needs typeof.
+template<typename F>
+class functor_type {
+    // NOTE: clang does not accept extra parenthesis `&(...)`.
+    typedef BOOST_TYPEOF_TPL(&F::operator()) call_ptr;
+public:
+    typedef
+        typename boost::function_types::function_type<
+            typename boost::mpl::push_front<
+                  typename boost::mpl::pop_front< // Remove functor type (1st).
+                    typename boost::function_types::parameter_types<
+                            call_ptr>::type
+                  >::type
+                , typename boost::function_types::result_type<call_ptr>::type
+            >::type
+        >::type
+    type;
+};
+
+// NOTE: When using boost::function in Boost.Typeof emulation mode, the user
+// has to register boost::functionN instead of boost::function in oder to
+// do TYPEOF(F::operator()). That is confusing, so boost::function is handled
+// separately so it does not require any Boost.Typeof registration at all.
+template<typename F>
+struct functor_type< boost::function<F> > {
+    typedef F type;
+};
+
+// Requires: F is a function type, pointer, reference, or monomorphic functor.
+// Returns: F's function type `result_type (arg1_type, arg2_type, ...)`.
+template<typename F>
+struct function_type {
+    typedef
+        typename boost::mpl::if_<boost::function_types::is_function<F>,
+            boost::mpl::identity<F>
+        ,
+            typename boost::mpl::if_<boost::function_types::
+                    is_function_pointer<F>,
+                boost::remove_pointer<F>
+            ,
+                typename boost::mpl::if_<boost::function_types::
+                        is_function_reference<F>,
+                    boost::remove_reference<F>
+                , // Else, requires that F is a functor.
+                    functor_type<F>
+                >::type
+            >::type
+        >::type
+    ::type type;
+};
+
+} } // namespace
+
+#endif // #include guard
+
diff --git a/include/boost/functional/value_factory.hpp b/include/boost/functional/value_factory.hpp
new file mode 100644
index 0000000..ba94c2a
--- /dev/null
+++ b/include/boost/functional/value_factory.hpp
@@ -0,0 +1,69 @@
+/*=============================================================================
+    Copyright (c) 2007 Tobias Schwinger
+  
+    Use modification and distribution are subject to the Boost Software 
+    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+==============================================================================*/
+
+#ifndef BOOST_FUNCTIONAL_VALUE_FACTORY_HPP_INCLUDED
+#   ifndef BOOST_PP_IS_ITERATING
+
+#     include <boost/preprocessor/iteration/iterate.hpp>
+#     include <boost/preprocessor/repetition/enum_params.hpp>
+#     include <boost/preprocessor/repetition/enum_binary_params.hpp>
+
+#     include <new>
+#     include <boost/pointee.hpp>
+#     include <boost/get_pointer.hpp>
+#     include <boost/non_type.hpp>
+#     include <boost/type_traits/remove_cv.hpp>
+
+#     ifndef BOOST_FUNCTIONAL_VALUE_FACTORY_MAX_ARITY
+#       define BOOST_FUNCTIONAL_VALUE_FACTORY_MAX_ARITY 10
+#     elif BOOST_FUNCTIONAL_VALUE_FACTORY_MAX_ARITY < 3
+#       undef  BOOST_FUNCTIONAL_VALUE_FACTORY_MAX_ARITY
+#       define BOOST_FUNCTIONAL_VALUE_FACTORY_MAX_ARITY 3
+#     endif
+
+namespace boost
+{
+    template< typename T >
+    class value_factory;
+
+    //----- ---- --- -- - -  -   -
+
+    template< typename T >
+    class value_factory
+    {
+      public:
+        typedef T result_type;
+
+        value_factory()
+        { }
+
+#     define BOOST_PP_FILENAME_1 <boost/functional/value_factory.hpp>
+#     define BOOST_PP_ITERATION_LIMITS (0,BOOST_FUNCTIONAL_VALUE_FACTORY_MAX_ARITY)
+#     include BOOST_PP_ITERATE()
+    };
+
+    template< typename T > class value_factory<T&>;
+    // forbidden, would create a dangling reference
+}
+#     define BOOST_FUNCTIONAL_VALUE_FACTORY_HPP_INCLUDED
+#   else // defined(BOOST_PP_IS_ITERATING)
+
+#     define N BOOST_PP_ITERATION()
+#     if N > 0
+    template< BOOST_PP_ENUM_PARAMS(N, typename T) >
+#     endif
+    inline result_type operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,T,& a)) const
+    {
+        return result_type(BOOST_PP_ENUM_PARAMS(N,a));
+    }
+#     undef N
+
+#   endif // defined(BOOST_PP_IS_ITERATING)
+
+#endif // include guard
+