Reimport boost/lambda as a separate project

35 files changed, 28 insertions, 13466 deletions

diff --git a/contrib/restricted/boost/CMakeLists.txt b/contrib/restricted/boost/CMakeLists.txt
index 7a62f910d7..9673b98ef9 100644
--- a/contrib/restricted/boost/CMakeLists.txt
+++ b/contrib/restricted/boost/CMakeLists.txt
@@ -34,6 +34,7 @@ target_link_libraries(contrib-restricted-boost INTERFACE
   restricted-boost-intrusive
   restricted-boost-io
   restricted-boost-iterator
+  restricted-boost-lambda
   restricted-boost-move
   restricted-boost-mp11
   restricted-boost-mpl
diff --git a/contrib/restricted/boost/boost/lambda/algorithm.hpp b/contrib/restricted/boost/boost/lambda/algorithm.hpp
deleted file mode 100644
index ced5f4e009..0000000000
--- a/contrib/restricted/boost/boost/lambda/algorithm.hpp
+++ /dev/null
@@ -1,1377 +0,0 @@
-// -- algorithm.hpp -- Boost Lambda Library -----------------------------------
-// Copyright (C) 2002 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2002 Gary Powell (gwpowell@hotmail.com)
-//
-// Distributed under 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)
-//
-// For more information, see http://www.boost.org
-
-#ifndef BOOST_LAMBDA_ALGORITHM_HPP
-#define BOOST_LAMBDA_ALGORITHM_HPP
-
-#include "boost/lambda/core.hpp"
-
-#include <algorithm>
-#include <iterator>  // for iterator_traits
-#include <utility> // for std::pair
-
-namespace boost {
-  namespace lambda {
-
-namespace ll {
-
-// for_each ---------------------------------
-
-struct for_each {
-  
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<3, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class C>
-  C
-  operator()(A a, A b, C c) const
-  { return ::std::for_each(a, b, c); }
-};
-
-// find  ---------------------------------
-
-struct find {
-  
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<1, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class C>
-  A
-  operator()(A a, A b, const C& c) const
-  { return ::std::find(a, b, c); }
-};
-
-
-// find_if  ---------------------------------
-
-struct find_if {
-  
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<1, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class C>
-  A
-  operator()(A a, A b, C c) const
-  { return ::std::find_if(a, b, c); }
-};
-
-// find_end  ---------------------------------
-
-struct find_end {
-
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<1, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class C>
-  A
-  operator()(A a, A b, C c, C d) const
-  { return ::std::find_end(a, b, c, d); }
-
-  template <class A, class C, class E>
-  A
-  operator()(A a, A b, C c, C d, E e) const
-  { return ::std::find_end(a, b, c, d, e); }
-
-};
-
-// find_first_of  ---------------------------------
-
-struct find_first_of {
-
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<1, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class C>
-  A
-  operator()(A a, A b, C c, C d) const
-  { return ::std::find_first_of(a, b, c, d); }
-
-  template <class A, class C, class E>
-  A
-  operator()(A a, A b, C c, C d, E e) const
-  { return ::std::find_first_of(a, b, c, d, e); }
-
-};
-
-// adjacent_find  ---------------------------------
-
-struct adjacent_find {
-
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<1, Args>::type 
-     >::type type; 
-  };
-
-  template <class A>
-  A
-  operator()(A a, A b) const
-  { return ::std::adjacent_find(a, b); }
-
-  template <class A, class C>
-  A
-  operator()(A a, A b, C c) const
-  { return ::std::adjacent_find(a, b, c); }
-
-};
-
-// count  ---------------------------------
-
-struct count {
-
-  template <class Args>
-  struct sig { 
-    typedef typename ::std::iterator_traits<
-      typename boost::remove_const<
-           typename boost::tuples::element<1, Args>::type
-      >::type 
-    >::difference_type type;
-  };
-
-  template <class A, class C >
-  typename ::std::iterator_traits<A>::difference_type
-  operator()(A a, A b, const C& c) const
-  { return ::std::count(a, b, c); }
-};
-
-// count_if  ---------------------------------
-
-struct count_if {
-
-  template <class Args>
-  struct sig { 
-    typedef typename ::std::iterator_traits<
-     typename boost::remove_const<
-           typename boost::tuples::element<1, Args>::type
-       >::type
-    >::difference_type type;
-  };
-
-  template <class A, class C >
-  typename ::std::iterator_traits<A>::difference_type
-  operator()(A a, A b, C c) const
-  { return ::std::count_if(a, b, c); }
-};
-
-
-// mismatch  ---------------------------------
-
-struct mismatch {
-
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<1, Args>::type
-     >::type element1_type; 
-
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<3, Args>::type
-     >::type element2_type; 
-
-    typedef ::std::pair< element1_type, element2_type > type;
-   };
-
-  template <class A, class C >
-  ::std::pair<A,C>
-  operator()(A a, A b, C c) const
-  { return ::std::mismatch(a, b, c); }
-
-  template <class A, class C, class D>
-  ::std::pair<A,C>
-  operator()(A a, A b, C c, D d) const
-  { return ::std::mismatch(a, b, c, d); }
-
-};
-
-// equal  ---------------------------------
-
-struct equal {
-
-  template <class Args>
-  struct sig { 
-    typedef bool type;
-  };
-
-  template <class A, class C >
-  bool
-  operator()(A a, A b, C c) const
-  { return ::std::equal(a, b, c); }
-
-  template <class A, class C, class D>
-  bool
-  operator()(A a, A b, C c, D d) const
-  { return ::std::equal(a, b, c, d); }
-
-};
-
-// search --------------------------------
-
-struct search {
-  
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<1, Args>::type
-     >::type type; 
-  };
-
-  template <class A, class C>
-  A
-  operator()(A a, A b, C c, C d) const
-  { return std::search(a, b, c, d);}
-
-  template <class A, class C, class E>
-  A
-  operator()(A a, A b, C c, C d, E e) const
-  { return std::search(a, b, c, d, e);}
-
-};
-
-// copy  ---------------------------------
-
-struct copy {
-
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<3, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class C>
-  C
-  operator()(A a, A b, C c) const
-  { return ::std::copy(a, b, c); }
-
-};
-
-// copy_backward  ---------------------------------
-
-struct copy_backward {
-
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<3, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class C>
-  C
-  operator()(A a, A b, C c) const
-  { return ::std::copy_backward(a, b, c); }
-
-};
-
-// swap  ---------------------------------
-
-struct swap {
-
-  template <class Args>
-  struct sig { 
-    typedef void type; 
-  };
-
-  template <class A>
-  void
-  operator()(A a, A b) const
-  { ::std::swap(a, b); }
-
-};
-
-// swap_ranges  ---------------------------------
-
-struct swap_ranges {
-
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<3, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class C>
-  C
-  operator()(A a, A b, C c) const
-  { return ::std::swap_ranges(a, b, c); }
-
-};
-
-// iter_swap  ---------------------------------
-
-struct iter_swap {
-
-  template <class Args>
-  struct sig { 
-     typedef void type; 
-  };
-
-  template <class A>
-  void 
-  operator()(A a, A b) const
-  { ::std::iter_swap(a, b); }
-
-};
-
-
-// transform --------------------------------
-
-struct transform {
-  
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<
-          boost::tuples::length<Args>::value - 2, 
-          Args
-      >::type
-     >::type type; 
-  };
-
-  template <class A, class C, class D>
-  C
-  operator()(A a, A b, C c, D d) const
-  { return std::transform(a, b, c, d);}
-
-  template <class A, class C, class D, class E>
-  D
-  operator()(A a, A b, C c, D d, E e) const
-  { return std::transform(a, b, c, d, e);}
-
-};
-
-// replace  ---------------------------------
-
-struct replace {
-
-  template <class Args>
-  struct sig {
-    typedef void type;
-  };
-
-  template <class A, class C>
-  void
-  operator()(A a, A b, const C& c, const C& d) const
-  { ::std::replace(a, b, c, d); }
-
-};
-
-// replace_if  ---------------------------------
-
-struct replace_if {
-
-  template <class Args>
-  struct sig {
-    typedef void type;
-  };
-
-  template <class A, class C, class D>
-  void
-  operator()(A a, A b, C c, const D& d) const
-  { ::std::replace_if(a, b, c, d); }
-
-};
-
-// replace_copy  ---------------------------------
-
-struct replace_copy {
-
- template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<3, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class C, class D>
-  C
-  operator()(A a, A b, C c, const D& d, const D& e) const
-  { return ::std::replace_copy(a, b, c, d, e); }
-
-};
-
-// replace_copy_if  ---------------------------------
-
-struct replace_copy_if {
-
- template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<3, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class C, class D, class E>
-  C
-  operator()(A a, A b, C c, D d, const E& e) const
-  { return ::std::replace_copy_if(a, b, c, d, e); }
-
-};
-
-// fill  ---------------------------------
-
-struct fill {
-
-  template <class Args>
-  struct sig { 
-     typedef void type; 
-  };
-
-  template <class A, class C>
-  void 
-  operator()(A a, A b, const C& c) const
-  { ::std::fill(a, b, c); }
-
-};
-
-// fill_n  ---------------------------------
-
-struct fill_n {
-
-  template <class Args>
-  struct sig { 
-     typedef void type; 
-  };
-
-  template <class A, class B, class C>
-  void 
-  operator()(A a, B b, const C& c) const
-  { ::std::fill_n(a, b, c); }
-
-};
-
-// generate  ---------------------------------
-
-struct generate {
-
-  template <class Args>
-  struct sig { 
-     typedef void type; 
-  };
-
-  template <class A, class C>
-  void 
-  operator()(A a, A b, C c) const
-  { ::std::generate(a, b, c); }
-
-};
-
-// generate_n  ---------------------------------
-
-struct generate_n {
-
-  template <class Args>
-  struct sig { 
-     typedef void type; 
-  };
-
-  template <class A, class B, class C>
-  void 
-  operator()(A a, B b, C c) const
-  { ::std::generate_n(a, b, c); }
-
-};
-
-// remove  ---------------------------------
-
-struct remove {
-
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<1, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class C >
-  A
-  operator()(A a, A b, const C& c) const
-  { return ::std::remove(a, b, c); }
-};
-
-// remove_if  ---------------------------------
-
-struct remove_if {
-
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-       typename boost::tuples::element<1, Args>::type
-     >::type type; 
-  };
-
-  template <class A, class C >
-  A
-  operator()(A a, A b, C c) const
-  { return ::std::remove_if(a, b, c); }
-};
-
-// remove_copy  ---------------------------------
-
-struct remove_copy {
-
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-       typename boost::tuples::element<3, Args>::type
-     >::type type; 
-  };
-
-  template <class A, class C, class D >
-  C
-  operator()(A a, A b, C c, const D& d) const
-  { return ::std::remove_copy(a, b, c, d); }
-};
-
-// remove_copy_if  ---------------------------------
-
-struct remove_copy_if {
-
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-       typename boost::tuples::element<3, Args>::type
-     >::type type; 
-  };
-
-  template <class A, class C, class D >
-  C
-  operator()(A a, A b, C c, D d) const
-  { return ::std::remove_copy_if(a, b, c, d); }
-};
-
-// unique  ---------------------------------
-
-struct unique {
-
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<1, Args>::type 
-     >::type type; 
-  };
-
-  template <class A>
-  A
-  operator()(A a, A b) const
-  { return ::std::unique(a, b); }
-
-  template <class A, class C>
-  A
-  operator()(A a, A b, C c) const
-  { return ::std::unique(a, b, c); }
-
-};
-
-// unique_copy  ---------------------------------
-
-struct unique_copy {
-
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<3, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class C >
-  C
-  operator()(A a, A b, C c) const
-  { return ::std::unique_copy(a, b, c); }
-
-  template <class A, class C, class D>
-  C
-  operator()(A a, A b, C c, D d) const
-  { return ::std::unique_copy(a, b, c, d); }
-
-};
-
-// reverse  ---------------------------------
-
-struct reverse {
-
-  template <class Args>
-  struct sig { 
-    typedef void type; 
-  };
-
-  template <class A>
-  void
-  operator()(A a, A b) const
-  { ::std::reverse(a, b); }
-
-};
-
-// reverse_copy  ---------------------------------
-
-struct reverse_copy {
-
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<3, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class C >
-  C
-  operator()(A a, A b, C c) const
-  { return ::std::reverse_copy(a, b, c); }
-
-};
-
-// rotate  ---------------------------------
-
-struct rotate {
-
-  template <class Args>
-  struct sig { 
-    typedef void type; 
-  };
-
-  template <class A>
-  void
-  operator()(A a, A b, A c) const
-  { ::std::rotate(a, b, c); }
-
-};
-
-// rotate_copy  ---------------------------------
-
-struct rotate_copy {
-
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<3, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class D>
-  D
-  operator()(A a, A b, A c, D d) const
-  { return ::std::rotate_copy(a, b, c, d); }
-
-};
-
-// random_shuffle  ---------------------------------
-
-struct random_shuffle {
-
-  template <class Args>
-  struct sig { 
-    typedef void type; 
-  };
-
-  template <class A>
-  void
-  operator()(A a, A b) const
-  { ::std::random_shuffle(a, b); }
-
-  template <class A, class C>
-  void
-  operator()(A a, A b, const C& c) const
-  { ::std::random_shuffle(a, b, c); }
-
-};
-
-
-// partition  ---------------------------------
-
-struct partition {
-
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<1, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class C>
-  A
-  operator()(A a, A b, C c) const
-  { return ::std::partition(a, b, c); }
-
-};
-
-// stable_partition  ---------------------------------
-
-struct stable_partition {
-
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<1, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class C>
-  A
-  operator()(A a, A b, C c) const
-  { return ::std::stable_partition(a, b, c); }
-
-};
-
-// sort  ---------------------------------
-
-struct sort {
-
-  template <class Args>
-  struct sig { 
-     typedef void type; 
-  };
-
-  template <class A>
-  void 
-  operator()(A a, A b) const
-  { ::std::sort(a, b); }
-
-  template <class A, class C>
-  void 
-  operator()(A a, A b, C c) const
-  { ::std::sort(a, b, c); }
-
-};
-
-// stable_sort  ---------------------------------
-
-struct stable_sort {
-
-  template <class Args>
-  struct sig { 
-     typedef void type; 
-  };
-
-  template <class A>
-  void 
-  operator()(A a, A b) const
-  { ::std::stable_sort(a, b); }
-
-  template <class A, class C>
-  void 
-  operator()(A a, A b, C c) const
-  { ::std::stable_sort(a, b, c); }
-
-};
-
-// partial_sort  ---------------------------------
-
-struct partial_sort {
-
-  template <class Args>
-  struct sig { 
-     typedef void type; 
-  };
-
-  template <class A>
-  void 
-  operator()(A a, A b, A c) const
-  { ::std::partial_sort(a, b, c); }
-
-  template <class A, class D>
-  void 
-  operator()(A a, A b, A c, D d) const
-  { ::std::partial_sort(a, b, c, d); }
-
-};
-
-// partial_sort_copy  ---------------------------------
-
-struct partial_sort_copy {
-
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-       typename boost::tuples::element<3, Args>::type
-     >::type type; 
-  };
-
-  template <class A, class C>
-  C
-  operator()(A a, A b, C c, C d) const
-  { return ::std::partial_sort_copy(a, b, c, d); }
-
-  template <class A, class C, class E >
-  C
-  operator()(A a, A b, C c, C d, E e) const
-  { return ::std::partial_sort_copy(a, b, c, d, e); }
-};
-
-// nth_element  ---------------------------------
-
-struct nth_element {
-
-  template <class Args>
-  struct sig { 
-     typedef void type; 
-  };
-
-  template <class A>
-  void 
-  operator()(A a, A b, A c) const
-  { ::std::nth_element(a, b, c); }
-
-  template <class A, class D>
-  void 
-  operator()(A a, A b, A c, D d) const
-  { ::std::nth_element(a, b, c, d); }
-
-};
-
-// lower_bound  ---------------------------------
-
-struct lower_bound {
-
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<1, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class C>
-  A
-  operator()(A a, A b, const C& c) const
-  { return ::std::lower_bound(a, b, c); }
-
-  template <class A, class C, class D>
-  A
-  operator()(A a, A b, const C& c, D d) const
-  { return ::std::lower_bound(a, b, c, d); }
-
-};
-
-// upper_bound  ---------------------------------
-
-struct upper_bound {
-
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<1, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class C>
-  A
-  operator()(A a, A b, const C& c) const
-  { return ::std::upper_bound(a, b, c); }
-
-  template <class A, class C, class D>
-  A
-  operator()(A a, A b, const C& c, D d) const
-  { return ::std::upper_bound(a, b, c, d); }
-
-};
-
-// equal_range  ---------------------------------
-
-struct equal_range {
-
- template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<1, Args>::type
-     >::type element_type; 
-
-    typedef ::std::pair< element_type, element_type > type;
-   };
-
-  template <class A, class C>
-  ::std::pair<A,A>
-  operator()(A a, A b, const C& c) const
-  { return ::std::equal_range(a, b, c); }
-
-  template <class A, class C, class D>
-  ::std::pair<A,A>
-  operator()(A a, A b, const C& c, D d) const
-  { return ::std::equal_range(a, b, c, d); }
-
-};
-
-// binary_search  ---------------------------------
-
-struct binary_search {
-
-  template <class Args>
-  struct sig { 
-    typedef bool type;
-  };
-
-  template <class A, class C >
-  bool
-  operator()(A a, A b, const C& c) const
-  { return ::std::binary_search(a, b, c); }
-
-  template <class A, class C, class D>
-  bool
-  operator()(A a, A b, const C& c, D d) const
-  { return ::std::binary_search(a, b, c, d); }
-
-};
-
-// merge --------------------------------
-
-struct merge {
-  
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<5, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class C, class E>
-  E
-  operator()(A a, A b, C c, C d, E e) const
-  { return std::merge(a, b, c, d, e);}
-
-  template <class A, class C, class E, class F>
-  E
-  operator()(A a, A b, C c, C d, E e, F f) const
-  { return std::merge(a, b, c, d, e, f);}
-
-};
-
-// inplace_merge  ---------------------------------
-
-struct inplace_merge {
-
-  template <class Args>
-  struct sig {
-    typedef void type;
-  };
-
-  template <class A>
-  void
-  operator()(A a, A b, A c) const
-  { ::std::inplace_merge(a, b, c); }
-
-  template <class A, class D>
-  void
-  operator()(A a, A b, A c, D d) const
-  { ::std::inplace_merge(a, b, c, d); }
-
-};
-
-// includes  ---------------------------------
-
-struct includes {
-
-  template <class Args>
-  struct sig { 
-    typedef bool type;
-  };
-
-  template <class A, class C>
-  bool
-  operator()(A a, A b, C c, C d) const
-  { return ::std::includes(a, b, c, d); }
-
-  template <class A, class C, class E>
-  bool
-  operator()(A a, A b, C c, C d, E e) const
-  { return ::std::includes(a, b, c, d, e); }
-
-};
-
-// set_union --------------------------------
-
-struct set_union {
-  
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<5, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class C, class E>
-  E
-  operator()(A a, A b, C c, C d, E e) const
-  { return std::set_union(a, b, c, d, e);}
-
-  template <class A, class C, class E, class F>
-  E
-  operator()(A a, A b, C c, C d, E e, F f) const
-  { return std::set_union(a, b, c, d, e, f);}
-
-};
-
-// set_intersection --------------------------------
-
-struct set_intersection {
-  
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<5, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class C, class E>
-  E
-  operator()(A a, A b, C c, C d, E e) const
-  { return std::set_intersection(a, b, c, d, e);}
-
-  template <class A, class C, class E, class F>
-  E
-  operator()(A a,  A b, C c, C d, E e, F f) const
-  { return std::set_intersection(a, b, c, d, e, f);}
-
-};
-
-// set_difference --------------------------------
-
-struct set_difference {
-  
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<5, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class C, class E>
-  E
-  operator()(A a, A b, C c, C d, E e) const
-  { return std::set_difference(a, b, c, d, e);}
-
-  template <class A, class C, class E, class F>
-  E
-  operator()(A a, A b, C c, C d, E e, F f) const
-  { return std::set_difference(a, b, c, d, e, f);}
-
-};
-
-
-// set_symmetric_difference --------------------------------
-
-struct set_symmetric_difference {
-  
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<5, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class C, class E>
-  E
-  operator()(A a, A b, C c, C d, E e) const
-  { return std::set_symmetric_difference(a, b, c, d, e);}
-
-  template <class A, class C, class E, class F>
-  E
-  operator()(A a, A b, C c, C d, E e, F f) const
-  { return std::set_symmetric_difference(a, b, c, d, e, f);}
-
-};
-
-// push_heap  ---------------------------------
-
-struct push_heap {
-
-  template <class Args>
-  struct sig { 
-    typedef void type; 
-  };
-
-  template <class A>
-  void
-  operator()(A a, A b) const
-  { ::std::push_heap(a, b); }
-
-  template <class A, class C>
-  void
-  operator()(A a, A b, C c) const
-  { ::std::push_heap(a, b, c); }
-
-};
-
-// pop_heap  ---------------------------------
-
-struct pop_heap {
-
-  template <class Args>
-  struct sig { 
-    typedef void type; 
-  };
-
-  template <class A>
-  void
-  operator()(A a, A b) const
-  { ::std::pop_heap(a, b); }
-
-  template <class A, class C>
-  void
-  operator()(A a, A b, C c) const
-  { ::std::pop_heap(a, b, c); }
-
-};
-
-
-// make_heap  ---------------------------------
-
-struct make_heap {
-
-  template <class Args>
-  struct sig { 
-    typedef void type; 
-  };
-
-  template <class A>
-  void
-  operator()(A a, A b) const
-  { ::std::make_heap(a, b); }
-
-  template <class A, class C>
-  void
-  operator()(A a, A b, C c) const
-  { ::std::make_heap(a, b, c); }
-
-};
-
-// sort_heap  ---------------------------------
-
-struct sort_heap {
-
-  template <class Args>
-  struct sig { 
-    typedef void type; 
-  };
-
-  template <class A>
-  void
-  operator()(A a, A b) const
-  { ::std::sort_heap(a, b); }
-
-  template <class A, class C>
-  void
-  operator()(A a, A b, C c) const
-  { ::std::sort_heap(a, b, c); }
-
-};
-
-// min  ---------------------------------
-
-struct min {
-
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<1, Args>::type 
-     >::type type; 
-  };
-
-  template <class A>
-  A
-  operator()(const A& a, const A& b) const
-  { return (::std::min)(a, b); }
-
-  template <class A, class C>
-  A
-  operator()(const A& a, const A& b, C c) const
-  { return (::std::min)(a, b, c); }
-
-};
-
-// max  ---------------------------------
-
-struct max {
-
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<1, Args>::type 
-     >::type type; 
-  };
-
-  template <class A>
-  A
-  operator()(const A& a, const A& b) const
-  { return (::std::max)(a, b); }
-
-  template <class A, class C>
-  A
-  operator()(const A& a, const A& b, C c) const
-  { return (::std::max)(a, b, c); }
-
-};
-
-struct min_element {
-
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<1, Args>::type 
-     >::type type; 
-  };
-
-  template <class A>
-  A
-  operator()(A a, A b) const
-  { return ::std::min_element(a, b); }
-
-  template <class A, class C>
-  A
-  operator()(A a, A b, C c) const
-  { return ::std::min_element(a, b, c); }
-
-};
-
-// max_element  ---------------------------------
-
-struct max_element {
-
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<1, Args>::type 
-     >::type type; 
-  };
-
-  template <class A>
-  A
-  operator()(A a, A b) const
-  { return ::std::max_element(a, b); }
-
-  template <class A, class C>
-  A
-  operator()(A a, A b, C c) const
-  { return ::std::max_element(a, b, c); }
-
-};
-
-
-// lexicographical_compare  ---------------------------------
-
-struct lexicographical_compare {
-
-  template <class Args>
-  struct sig { 
-    typedef bool type;
-  };
-
-  template <class A, class C>
-  bool
-  operator()(A a, A b, C c, C d) const
-  { return ::std::lexicographical_compare(a, b, c, d); }
-
-  template <class A, class C, class E>
-  bool
-  operator()(A a, A b, C c, C d, E e) const
-  { return ::std::lexicographical_compare(a, b, c, d, e); }
-
-};
-
-// next_permutation  ---------------------------------
-
-struct next_permutation {
-
-  template <class Args>
-  struct sig { 
-    typedef bool type;
-  };
-
-  template <class A>
-  bool
-  operator()(A a, A b) const
-  { return ::std::next_permutation(a, b); }
-
-  template <class A, class C >
-  bool
-  operator()(A a, A b, C c) const
-  { return ::std::next_permutation(a, b, c); }
-
-};
-
-// prev_permutation  ---------------------------------
-
-struct prev_permutation {
-
-  template <class Args>
-  struct sig { 
-    typedef bool type;
-  };
-
-  template <class A>
-  bool
-  operator()(A a, A b) const
-  { return ::std::prev_permutation(a, b); }
-
-  template <class A, class C >
-  bool
-  operator()(A a, A b, C c) const
-  { return ::std::prev_permutation(a, b, c); }
-
-};
-
-
-
-
-
-} // end of ll namespace
-
-// There is no good way to call an overloaded member function in a 
-// lambda expression. 
-// The macro below defines a function object class for calling a
-// const_iterator returning member function of a container.
-
-#define CALL_MEMBER(X)                                     \
-struct call_##X {                                          \
-template <class Args>                                      \
-  struct sig {                                             \
-    typedef typename boost::remove_const<                  \
-        typename boost::tuples::element<1, Args>::type     \
-     >::type::const_iterator type;                         \
-  };                                                       \
-                                                           \
-  template<class T>                                        \
-  typename T::const_iterator                               \
-  operator()(const T& t) const                             \
-  {                                                        \
-    return t.X();                                          \
-  }                                                        \
-};
-
-// create call_begin and call_end classes
-CALL_MEMBER(begin)
-CALL_MEMBER(end)
-
-#undef CALL_MEMBER
-
-} // end of lambda namespace
-} // end of boost namespace
-
-
-
-#endif
diff --git a/contrib/restricted/boost/boost/lambda/bind.hpp b/contrib/restricted/boost/boost/lambda/bind.hpp
deleted file mode 100644
index 0371393cba..0000000000
--- a/contrib/restricted/boost/boost/lambda/bind.hpp
+++ /dev/null
@@ -1,19 +0,0 @@
-// -- bind.hpp -- Boost Lambda Library --------------------------------------
-
-// Copyright (C) 1999-2001 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//                         Gary Powell (gwpowell@hotmail.com)
-//
-// Distributed under 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)
-//
-// For more information, see http://www.boost.org 
-
-#ifndef BOOST_LAMBDA_BIND_HPP
-#define BOOST_LAMBDA_BIND_HPP
-
-#include "boost/lambda/core.hpp"
-
-#include "boost/lambda/detail/bind_functions.hpp"
-    
-#endif
diff --git a/contrib/restricted/boost/boost/lambda/casts.hpp b/contrib/restricted/boost/boost/lambda/casts.hpp
deleted file mode 100644
index 8b3d3a7822..0000000000
--- a/contrib/restricted/boost/boost/lambda/casts.hpp
+++ /dev/null
@@ -1,226 +0,0 @@
-// - casts.hpp -- BLambda Library -------------
-//
-// Copyright (C) 2000 Gary Powell (powellg@amazon.com)
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//
-// Distributed under 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)
-//
-// For more information, see http://www.boost.org
-
-// -----------------------------------------------
-
-#if !defined(BOOST_LAMBDA_CASTS_HPP)
-#define BOOST_LAMBDA_CASTS_HPP
-
-#include "boost/lambda/detail/suppress_unused.hpp"
-#include "boost/lambda/core.hpp"
-
-#include <typeinfo>
-
-namespace boost { 
-namespace lambda {
-
-template<class Act, class Args>
-struct return_type_N;
-
-template<class T> class cast_action;
-
-template<class T> class static_cast_action;
-template<class T> class dynamic_cast_action;
-template<class T> class const_cast_action;
-template<class T> class reinterpret_cast_action;
-
-class typeid_action;
-class sizeof_action;
-
-// Cast actions
-
-template<class T> class cast_action<static_cast_action<T> > 
-{
-public:
-  template<class RET, class Arg1>
-  static RET apply(Arg1 &a1) {
-    return static_cast<RET>(a1);
-  }
-};
-
-template<class T> class cast_action<dynamic_cast_action<T> > {
-public:
-  template<class RET, class Arg1>
-  static RET apply(Arg1 &a1) {
-    return dynamic_cast<RET>(a1);
-  }
-};
-
-template<class T> class cast_action<const_cast_action<T> > {
-public:
-  template<class RET, class Arg1>
-  static RET apply(Arg1 &a1) {
-    return const_cast<RET>(a1);
-  }
-};
-
-template<class T> class cast_action<reinterpret_cast_action<T> > {
-public:
-  template<class RET, class Arg1>
-  static RET apply(Arg1 &a1) {
-    return reinterpret_cast<RET>(a1);
-  }
-};
-
-// typeid action
-class typeid_action {
-public:
-  template<class RET, class Arg1>
-  static RET apply(Arg1 &a1) {
-    detail::suppress_unused_variable_warnings(a1);
-    return typeid(a1);
-  }
-};
-
-// sizeof action
-class sizeof_action
-{
-public:
-  template<class RET, class Arg1>
-  static RET apply(Arg1 &a1) {
-    return sizeof(a1);
-  }
-};
-
-
-// return types of casting lambda_functors (all "T" type.)
-
-template<template <class> class cast_type, class T, class A>
-struct return_type_N<cast_action< cast_type<T> >, A> { 
-  typedef T type;
-};
-
-// return type of typeid_action
-template<class A>
-struct return_type_N<typeid_action, A> { 
-  typedef std::type_info const & type;
-};
-
-// return type of sizeof_action
-
-template<class A>
-struct return_type_N<sizeof_action, A> { 
-  typedef std::size_t type;
-};
-
-
-// the four cast & typeid overloads.
-// casts can take ordinary variables (not just lambda functors)
-
-// static_cast 
-template <class T, class Arg1>
-inline const lambda_functor<
-  lambda_functor_base<
-    action<1, cast_action<static_cast_action<T> > >, 
-    tuple<typename const_copy_argument <const Arg1>::type>
-  > 
->
-ll_static_cast(const Arg1& a1) { 
-  return 
-    lambda_functor_base<
-      action<1, cast_action<static_cast_action<T> > >, 
-      tuple<typename const_copy_argument <const Arg1>::type> 
-    >
-  ( tuple<typename const_copy_argument <const Arg1>::type>(a1));
-}
-
-// dynamic_cast
-template <class T, class Arg1>
-inline const lambda_functor<
-  lambda_functor_base<
-    action<1, cast_action<dynamic_cast_action<T> > >, 
-    tuple<typename const_copy_argument <const Arg1>::type>
-  > 
->
-ll_dynamic_cast(const Arg1& a1) { 
-  return 
-    lambda_functor_base<
-      action<1, cast_action<dynamic_cast_action<T> > >, 
-      tuple<typename const_copy_argument <const Arg1>::type>
-    > 
-  ( tuple<typename const_copy_argument <const Arg1>::type>(a1));
-}
-
-// const_cast
-template <class T, class Arg1>
-inline const lambda_functor<
-  lambda_functor_base<
-    action<1, cast_action<const_cast_action<T> > >, 
-    tuple<typename const_copy_argument <const Arg1>::type>
-  > 
->
-ll_const_cast(const Arg1& a1) { 
-  return 
-      lambda_functor_base<
-        action<1, cast_action<const_cast_action<T> > >, 
-        tuple<typename const_copy_argument <const Arg1>::type>
-      > 
-      ( tuple<typename const_copy_argument <const Arg1>::type>(a1));
-}
-
-// reinterpret_cast
-template <class T, class Arg1>
-inline const lambda_functor<
-  lambda_functor_base<
-    action<1, cast_action<reinterpret_cast_action<T> > >, 
-    tuple<typename const_copy_argument <const Arg1>::type>
-  > 
->
-ll_reinterpret_cast(const Arg1& a1) { 
-  return 
-      lambda_functor_base<
-        action<1, cast_action<reinterpret_cast_action<T> > >, 
-        tuple<typename const_copy_argument <const Arg1>::type> 
-      > 
-      ( tuple<typename const_copy_argument <const Arg1>::type>(a1));
-}
-
-// typeid
-// can be applied to a normal variable as well (can refer to a polymorphic
-// class object)
-template <class Arg1>
-inline const lambda_functor<
-  lambda_functor_base<
-    action<1, typeid_action>, 
-    tuple<typename const_copy_argument <const Arg1>::type>
-  > 
->
-ll_typeid(const Arg1& a1) { 
-  return 
-      lambda_functor_base<
-        action<1, typeid_action>, 
-        tuple<typename const_copy_argument <const Arg1>::type>
-      > 
-      ( tuple<typename const_copy_argument <const Arg1>::type>(a1));
-}
-
-// sizeof(expression)
-// Always takes a lambda expression (if not, built in sizeof will do)
-template <class Arg1>
-inline const lambda_functor<
-  lambda_functor_base<
-    action<1, sizeof_action>, 
-    tuple<lambda_functor<Arg1> >
-  > 
->
-ll_sizeof(const lambda_functor<Arg1>& a1) { 
-  return 
-      lambda_functor_base<
-        action<1, sizeof_action>, 
-        tuple<lambda_functor<Arg1> >
-      > 
-      ( tuple<lambda_functor<Arg1> >(a1));
-}
-
-} // namespace lambda 
-} // namespace boost
-
-#endif
diff --git a/contrib/restricted/boost/boost/lambda/closures.hpp b/contrib/restricted/boost/boost/lambda/closures.hpp
deleted file mode 100644
index f09c8a5885..0000000000
--- a/contrib/restricted/boost/boost/lambda/closures.hpp
+++ /dev/null
@@ -1,274 +0,0 @@
-/*=============================================================================
-    Adaptable closures
-
-    Phoenix V0.9
-    Copyright (c) 2001-2002 Joel de Guzman
-
-    Distributed under 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)
-
-    URL: http://spirit.sourceforge.net/
-
-==============================================================================*/
-#ifndef PHOENIX_CLOSURES_HPP
-#define PHOENIX_CLOSURES_HPP
-
-///////////////////////////////////////////////////////////////////////////////
-#include "boost/lambda/core.hpp"
-///////////////////////////////////////////////////////////////////////////////
-namespace boost {
-namespace lambda {
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  Adaptable closures
-//
-//      The framework will not be complete without some form of closures
-//      support. Closures encapsulate a stack frame where local
-//      variables are created upon entering a function and destructed
-//      upon exiting. Closures provide an environment for local
-//      variables to reside. Closures can hold heterogeneous types.
-//
-//      Phoenix closures are true hardware stack based closures. At the
-//      very least, closures enable true reentrancy in lambda functions.
-//      A closure provides access to a function stack frame where local
-//      variables reside. Modeled after Pascal nested stack frames,
-//      closures can be nested just like nested functions where code in
-//      inner closures may access local variables from in-scope outer
-//      closures (accessing inner scopes from outer scopes is an error
-//      and will cause a run-time assertion failure).
-//
-//      There are three (3) interacting classes:
-//
-//      1) closure:
-//
-//      At the point of declaration, a closure does not yet create a
-//      stack frame nor instantiate any variables. A closure declaration
-//      declares the types and names[note] of the local variables. The
-//      closure class is meant to be subclassed. It is the
-//      responsibility of a closure subclass to supply the names for
-//      each of the local variable in the closure. Example:
-//
-//          struct my_closure : closure<int, string, double> {
-//
-//              member1 num;        // names the 1st (int) local variable
-//              member2 message;    // names the 2nd (string) local variable
-//              member3 real;       // names the 3rd (double) local variable
-//          };
-//
-//          my_closure clos;
-//
-//      Now that we have a closure 'clos', its local variables can be
-//      accessed lazily using the dot notation. Each qualified local
-//      variable can be used just like any primitive actor (see
-//      primitives.hpp). Examples:
-//
-//          clos.num = 30
-//          clos.message = arg1
-//          clos.real = clos.num * 1e6
-//
-//      The examples above are lazily evaluated. As usual, these
-//      expressions return composite actors that will be evaluated
-//      through a second function call invocation (see operators.hpp).
-//      Each of the members (clos.xxx) is an actor. As such, applying
-//      the operator() will reveal its identity:
-//
-//          clos.num() // will return the current value of clos.num
-//
-//      *** [note] Acknowledgement: Juan Carlos Arevalo-Baeza (JCAB)
-//      introduced and initilally implemented the closure member names
-//      that uses the dot notation.
-//
-//      2) closure_member
-//
-//      The named local variables of closure 'clos' above are actually
-//      closure members. The closure_member class is an actor and
-//      conforms to its conceptual interface. member1..memberN are
-//      predefined typedefs that correspond to each of the listed types
-//      in the closure template parameters.
-//
-//      3) closure_frame
-//
-//      When a closure member is finally evaluated, it should refer to
-//      an actual instance of the variable in the hardware stack.
-//      Without doing so, the process is not complete and the evaluated
-//      member will result to an assertion failure. Remember that the
-//      closure is just a declaration. The local variables that a
-//      closure refers to must still be instantiated.
-//
-//      The closure_frame class does the actual instantiation of the
-//      local variables and links these variables with the closure and
-//      all its members. There can be multiple instances of
-//      closure_frames typically situated in the stack inside a
-//      function. Each closure_frame instance initiates a stack frame
-//      with a new set of closure local variables. Example:
-//
-//          void foo()
-//          {
-//              closure_frame<my_closure> frame(clos);
-//              /* do something */
-//          }
-//
-//      where 'clos' is an instance of our closure 'my_closure' above.
-//      Take note that the usage above precludes locally declared
-//      classes. If my_closure is a locally declared type, we can still
-//      use its self_type as a paramater to closure_frame:
-//
-//          closure_frame<my_closure::self_type> frame(clos);
-//
-//      Upon instantiation, the closure_frame links the local variables
-//      to the closure. The previous link to another closure_frame
-//      instance created before is saved. Upon destruction, the
-//      closure_frame unlinks itself from the closure and relinks the
-//      preceding closure_frame prior to this instance.
-//
-//      The local variables in the closure 'clos' above is default
-//      constructed in the stack inside function 'foo'. Once 'foo' is
-//      exited, all of these local variables are destructed. In some
-//      cases, default construction is not desirable and we need to
-//      initialize the local closure variables with some values. This
-//      can be done by passing in the initializers in a compatible
-//      tuple. A compatible tuple is one with the same number of
-//      elements as the destination and where each element from the
-//      destination can be constructed from each corresponding element
-//      in the source. Example:
-//
-//          tuple<int, char const*, int> init(123, "Hello", 1000);
-//          closure_frame<my_closure> frame(clos, init);
-//
-//      Here now, our closure_frame's variables are initialized with
-//      int: 123, char const*: "Hello" and int: 1000.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  closure_frame class
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename ClosureT>
-class closure_frame : public ClosureT::tuple_t {
-
-public:
-
-    closure_frame(ClosureT& clos)
-    : ClosureT::tuple_t(), save(clos.frame), frame(clos.frame)
-    { clos.frame = this; }
-
-    template <typename TupleT>
-    closure_frame(ClosureT& clos, TupleT const& init)
-    : ClosureT::tuple_t(init), save(clos.frame), frame(clos.frame)
-    { clos.frame = this; }
-
-    ~closure_frame()
-    { frame = save; }
-
-private:
-
-    closure_frame(closure_frame const&);            // no copy
-    closure_frame& operator=(closure_frame const&); // no assign
-
-    closure_frame* save;
-    closure_frame*& frame;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  closure_member class
-//
-///////////////////////////////////////////////////////////////////////////////
-template <int N, typename ClosureT>
-class closure_member {
-
-public:
-
-    typedef typename ClosureT::tuple_t tuple_t;
-
-    closure_member()
-    : frame(ClosureT::closure_frame_ref()) {}
-
-    template <typename TupleT>
-    struct sig {
-
-        typedef typename detail::tuple_element_as_reference<
-            N, typename ClosureT::tuple_t
-        >::type type;
-    };
-
-    template <class Ret, class A, class B, class C>
-    //    typename detail::tuple_element_as_reference
-    //        <N, typename ClosureT::tuple_t>::type
-    Ret
-    call(A&, B&, C&) const
-    {
-        assert(frame);
-        return boost::tuples::get<N>(*frame);
-    }
-
-
-private:
-
-    typename ClosureT::closure_frame_t*& frame;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  closure class
-//
-///////////////////////////////////////////////////////////////////////////////
-template <
-    typename T0 = null_type,
-    typename T1 = null_type,
-    typename T2 = null_type,
-    typename T3 = null_type,
-    typename T4 = null_type
->
-class closure {
-
-public:
-
-    typedef tuple<T0, T1, T2, T3, T4> tuple_t;
-    typedef closure<T0, T1, T2, T3, T4> self_t;
-    typedef closure_frame<self_t> closure_frame_t;
-
-                            closure()
-                            : frame(0)      { closure_frame_ref(&frame); }
-    closure_frame_t&        context()       { assert(frame); return frame; }
-    closure_frame_t const&  context() const { assert(frame); return frame; }
-
-    typedef lambda_functor<closure_member<0, self_t> > member1;
-    typedef lambda_functor<closure_member<1, self_t> > member2;
-    typedef lambda_functor<closure_member<2, self_t> > member3;
-    typedef lambda_functor<closure_member<3, self_t> > member4;
-    typedef lambda_functor<closure_member<4, self_t> > member5;
-
-private:
-
-    closure(closure const&);            // no copy
-    closure& operator=(closure const&); // no assign
-
-    template <int N, typename ClosureT>
-    friend class closure_member;
-
-    template <typename ClosureT>
-    friend class closure_frame;
-
-    static closure_frame_t*&
-    closure_frame_ref(closure_frame_t** frame_ = 0)
-    {
-        static closure_frame_t** frame = 0;
-        if (frame_ != 0)
-            frame = frame_;
-        return *frame;
-    }
-
-    closure_frame_t* frame;
-};
-
-}}
-   //  namespace 
-
-#endif
diff --git a/contrib/restricted/boost/boost/lambda/construct.hpp b/contrib/restricted/boost/boost/lambda/construct.hpp
deleted file mode 100644
index 06da171228..0000000000
--- a/contrib/restricted/boost/boost/lambda/construct.hpp
+++ /dev/null
@@ -1,240 +0,0 @@
-// - construct.hpp -- Lambda Library -------------
-//
-// Copyright (C) 2000 Gary Powell (powellg@amazon.com)
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//
-// Distributed under 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)
-//
-// For more information, see http://www.boost.org
-//
-// -----------------------------------------------
-
-#if !defined(BOOST_LAMBDA_CONSTRUCT_HPP)
-#define BOOST_LAMBDA_CONSTRUCT_HPP
-
-#include "boost/type_traits/remove_cv.hpp"
-#include "boost/type_traits/is_pointer.hpp"
-
-namespace boost { 
-namespace lambda {
-
-  // constructor is used together with bind. constructor<A> creates a bindable
-  // function object that passes its arguments forward to a constructor call
-  // of type A
-
-template<class T> struct constructor {
-
-  template <class U> struct sig { typedef T type; };
-
-  T operator()() const {
-    return T();
-  }
-
-  template<class A1>
-  T operator()(A1& a1) const {
-    return T(a1);
-  }
-
-  template<class A1, class A2>
-  T operator()(A1& a1, A2& a2) const {
-    return T(a1, a2);
-  }
-
-  template<class A1, class A2, class A3>
-  T operator()(A1& a1, A2& a2, A3& a3) const {
-    return T(a1, a2, a3);
-  }
-
-  template<class A1, class A2, class A3, class A4>
-  T operator()(A1& a1, A2& a2, A3& a3, A4& a4) const {
-    return T(a1, a2, a3, a4);
-  }
-
-  template<class A1, class A2, class A3, class A4, class A5>
-  T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) const {
-    return T(a1, a2, a3, a4, a5);
-  }
-
-  template<class A1, class A2, class A3, class A4, class A5, class A6>
-  T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) const {
-    return T(a1, a2, a3, a4, a5, a6);
-  }
-
-  template<class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-  T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) const {
-    return T(a1, a2, a3, a4, a5, a6, a7);
-  }
-
-  template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-  T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) const {
-    return T(a1, a2, a3, a4, a5, a6, a7, a8);
-  }
-
-  template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-  T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) const {
-    return T(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-  }
-
-  template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-  T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10) const {
-    return T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
-  }
-
-};
-
-
-namespace detail {
-
-// A standard conforming compiler could disambiguate between
-// A1* and A1&, but not all compilers do that, so we need the
-// helpers
-
-
-template <bool IsPointer>
-struct destructor_helper {
-
-  template<class A1>
-  static void exec(A1& a1) {
-    // remove all the qualifiers, not sure whether it is necessary
-    typedef typename boost::remove_cv<A1>::type plainA1;
-     a1.~plainA1();
-  }
-};
-
-template <>
-struct destructor_helper<true> {
-
-  template<class A1>
-  static void exec(A1* a1) {
-    typedef typename boost::remove_cv<A1>::type plainA1;
-    (*a1).~plainA1();
-  }
-};
-
-}
-
-// destructor funtion object
-struct destructor {  
-
-  template <class T> struct sig { typedef void type; };  
-
-  template<class A1>
-  void operator()(A1& a1) const {
-    typedef typename boost::remove_cv<A1>::type plainA1;
-    detail::destructor_helper<boost::is_pointer<plainA1>::value>::exec(a1);
-  }
-};
-
-
-
-// new_ptr is used together with bind.
-
-  // note: placement new is not supported
-
-template<class T> struct new_ptr {
-
-  template <class U> struct sig { typedef T* type; };  
-
-  T* operator()() const {
-    return new T();
-  }
-
-  template<class A1>
-  T* operator()(A1& a1) const {
-    return new T(a1);
-  }
-
-  template<class A1, class A2>
-  T* operator()(A1& a1, A2& a2) const {
-    return new T(a1, a2);
-  }
-
-  template<class A1, class A2, class A3>
-  T* operator()(A1& a1, A2& a2, A3& a3) const {
-    return new T(a1, a2, a3);
-  }
-
-  template<class A1, class A2, class A3, class A4>
-  T* operator()(A1& a1, A2& a2, A3& a3, A4& a4) const {
-    return new T(a1, a2, a3, a4);
-  }
-
-  template<class A1, class A2, class A3, class A4, class A5>
-  T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) const {
-    return new T(a1, a2, a3, a4, a5);
-  }
-
-  template<class A1, class A2, class A3, class A4, class A5, class A6>
-  T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) const {
-    return new T(a1, a2, a3, a4, a5, a6);
-  }
-
-  template<class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-  T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) const {
-    return new T(a1, a2, a3, a4, a5, a6, a7);
-  }
-
-  template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-  T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) const {
-    return new T(a1, a2, a3, a4, a5, a6, a7, a8);
-  }
-
-  template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-  T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) const {
-    return new T(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-  }
-
-  template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-  T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10) const {
-    return new T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
-  }
-
-};
-
-// delete_ptr return void
-
-struct delete_ptr {
-
-  template <class U> struct sig { typedef void type; };  
-
-  template <class A1>
-  void operator()(A1& a1) const {
-    delete a1;
-  }
-
-};
-
-
-// new_array is used together with bind.
-
-template<class T> struct new_array {
-
-  template <class U> struct sig { typedef T* type; };  
-
-  T* operator()(int size) const {
-    return new T[size];
-  }
-};
-
-
-// delete_ptr return void
-
-struct delete_array {
-
-  template <class U> struct sig { typedef void type; };  
-
-  template <class A1>
-  void operator()(A1& a1) const {
-    delete[] a1;
-  }
-
-};
-
-
-
-} // namespace lambda 
-} // namespace boost
-
-#endif
diff --git a/contrib/restricted/boost/boost/lambda/control_structures.hpp b/contrib/restricted/boost/boost/lambda/control_structures.hpp
deleted file mode 100644
index 74cb97ce71..0000000000
--- a/contrib/restricted/boost/boost/lambda/control_structures.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-// -- control_structures.hpp -- Boost Lambda Library --------------------------
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//
-// Distributed under 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)
-//
-// For more information, see www.boost.org
-
-#ifndef BOOST_LAMBDA_CONTROL_STRUCTURES_HPP
-#define BOOST_LAMBDA_CONTROL_STRUCTURES_HPP
-
-
-#include "boost/lambda/core.hpp"
-
-// Arithmetic type promotion needed for if_then_else_return
-#include "boost/lambda/detail/operator_actions.hpp"
-#include "boost/lambda/detail/operator_return_type_traits.hpp"
-
-#include "boost/lambda/if.hpp"
-#include "boost/lambda/loops.hpp"
-
-#endif
diff --git a/contrib/restricted/boost/boost/lambda/core.hpp b/contrib/restricted/boost/boost/lambda/core.hpp
deleted file mode 100644
index b81fdf88a1..0000000000
--- a/contrib/restricted/boost/boost/lambda/core.hpp
+++ /dev/null
@@ -1,81 +0,0 @@
-// -- core.hpp -- Boost Lambda Library -------------------------------------
-//
-// Copyright (C) 2000 Gary Powell (powellg@amazon.com)
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//
-// Distributed under 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)
-//
-// For more information, see www.boost.org
-// 
-// Includes the core of LL, without any real features for client:
-// 
-// tuples, lambda functors, return type deduction templates,
-// argument substitution mechanism (select functions)
-// 
-// Some functionality comes as well:
-// Assignment and subscript operators, as well as function
-// call operator for placeholder variables.
-// -------------------------------------------------------------------------
-
-#ifndef BOOST_LAMBDA_CORE_HPP
-#define BOOST_LAMBDA_CORE_HPP
-
-#include "boost/config.hpp"
-
-#include "boost/type_traits/transform_traits.hpp"
-#include "boost/type_traits/cv_traits.hpp"
-
-#include "boost/tuple/tuple.hpp"
-
-// inject some of the tuple names into lambda 
-namespace boost {
-namespace lambda {
-
-using ::boost::tuples::tuple;
-using ::boost::tuples::null_type;
-
-} // lambda
-} // boost
-
-#include "boost/lambda/detail/lambda_config.hpp"
-#include "boost/lambda/detail/lambda_fwd.hpp"
-
-#include "boost/lambda/detail/arity_code.hpp"
-#include "boost/lambda/detail/actions.hpp"
-
-#include "boost/lambda/detail/lambda_traits.hpp"
-
-#include "boost/lambda/detail/function_adaptors.hpp"
-#include "boost/lambda/detail/return_type_traits.hpp"
-
-#include "boost/lambda/detail/select_functions.hpp"
-
-#include "boost/lambda/detail/lambda_functor_base.hpp"
-
-#include "boost/lambda/detail/lambda_functors.hpp"
-
-#include "boost/lambda/detail/ret.hpp"
-
-namespace boost {
-namespace lambda {
-
-namespace {
-
-  // These are constants types and need to be initialised
-  boost::lambda::placeholder1_type free1 = boost::lambda::placeholder1_type();
-  boost::lambda::placeholder2_type free2 = boost::lambda::placeholder2_type();
-  boost::lambda::placeholder3_type free3 = boost::lambda::placeholder3_type();
-
-  boost::lambda::placeholder1_type& BOOST_ATTRIBUTE_UNUSED _1 = free1;
-  boost::lambda::placeholder2_type& BOOST_ATTRIBUTE_UNUSED _2 = free2;
-  boost::lambda::placeholder3_type& BOOST_ATTRIBUTE_UNUSED _3 = free3;
-  // _1, _2, ... naming scheme by Peter Dimov
-} // unnamed
-   
-} // lambda
-} // boost
-   
-   
-#endif //BOOST_LAMBDA_CORE_HPP
diff --git a/contrib/restricted/boost/boost/lambda/detail/actions.hpp b/contrib/restricted/boost/boost/lambda/detail/actions.hpp
deleted file mode 100644
index 668799f9fe..0000000000
--- a/contrib/restricted/boost/boost/lambda/detail/actions.hpp
+++ /dev/null
@@ -1,174 +0,0 @@
-// -- Boost Lambda Library - actions.hpp ----------------------------------
-
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//
-// Distributed under 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)
-
-// For more information, see www.boost.org
-
-// ----------------------------------------------------------------
-
-#ifndef BOOST_LAMBDA_ACTIONS_HPP
-#define BOOST_LAMBDA_ACTIONS_HPP
-
-namespace boost { 
-namespace lambda {
-
-
-
-template<int Arity, class Act> class action;
-
-// these need to be defined here, since the corresponding lambda 
-// functions are members of lambda_functor classes
-
-class assignment_action {};
-class subscript_action {};
-
-template <class Action> class other_action;
-
-// action for specifying the explicit return type
-template <class RET> class explicit_return_type_action {};
-
-// action for preventing the expansion of a lambda expression
-struct protect_action {};
-
-  // must be defined here, comma is a special case
-struct comma_action {};
-
-
-  // actions, for which the existence of protect is checked in return type 
-  // deduction.
-
-template <class Action> struct is_protectable {
-  BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-// NOTE: comma action is protectable. Other protectable actions
-// are listed in operator_actions.hpp
-
-template<> struct is_protectable<other_action<comma_action> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-
-
-namespace detail {
-
-  // this type is used in return type deductions to signal that deduction 
-  // did not find a result. It does not necessarily mean an error, it commonly
-  // means that something else should be tried.
-  class unspecified {};
-}
-
-  // function action is a special case: bind functions can be called with 
-  // the return type specialized explicitly e.g. bind<int>(foo);
-  // If this call syntax is used, the return type is stored in the latter
-  // argument of function_action template. Otherwise the argument gets the type
-  // 'unspecified'.
-  // This argument is only relevant in the return type deduction code
-template <int I, class Result_type = detail::unspecified> 
-class function_action {};
-   
-template<class T> class function_action<1, T> {
-public:
-  template<class RET, class A1>
-  static RET apply(A1& a1) {
-    return function_adaptor<typename boost::remove_cv<A1>::type>::
-      template apply<RET>(a1);
-  }
-};
-
-template<class T> class function_action<2, T> {
-public:
-  template<class RET, class A1, class A2>
-  static RET apply(A1& a1, A2& a2) {
-    return function_adaptor<typename boost::remove_cv<A1>::type>::
-      template apply<RET>(a1, a2);
-  }
-};
-
-template<class T> class function_action<3, T> {
-public:
-  template<class RET, class A1, class A2, class A3>
-  static RET apply(A1& a1, A2& a2, A3& a3) {
-    return function_adaptor<typename boost::remove_cv<A1>::type>::
-      template apply<RET>(a1, a2, a3);
-  }
-};
-
-template<class T> class function_action<4, T> {
-public:
-  template<class RET, class A1, class A2, class A3, class A4>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4) {
-    return function_adaptor<typename boost::remove_cv<A1>::type>::
-      template apply<RET>(a1, a2, a3, a4);
-  }
-};
-
-template<class T> class function_action<5, T> {
-public:
-  template<class RET, class A1, class A2, class A3, class A4, class A5>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
-    return function_adaptor<typename boost::remove_cv<A1>::type>::
-      template apply<RET>(a1, a2, a3, a4, a5);
-  }
-};
-
-template<class T> class function_action<6, T> {
-public:
-  template<class RET, class A1, class A2, class A3, class A4, class A5, 
-           class A6>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
-    return function_adaptor<typename boost::remove_cv<A1>::type>::
-      template apply<RET>(a1, a2, a3, a4, a5, a6);
-  }
-};
-
-template<class T> class function_action<7, T> {
-public:
-  template<class RET, class A1, class A2, class A3, class A4, class A5,  
-           class A6, class A7>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
-    return function_adaptor<typename boost::remove_cv<A1>::type>::
-      template apply<RET>(a1, a2, a3, a4, a5, a6, a7);
-  }
-};
-
-template<class T> class function_action<8, T> {
-public:
-  template<class RET, class A1, class A2, class A3, class A4, class A5, 
-           class A6, class A7, class A8>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, 
-                   A8& a8) {
-    return function_adaptor<typename boost::remove_cv<A1>::type>::
-      template apply<RET>(a1, a2, a3, a4, a5, a6, a7, a8);
-  }
-};
-
-template<class T> class function_action<9, T> {
-public:
-  template<class RET, class A1, class A2, class A3, class A4, class A5, 
-           class A6, class A7, class A8, class A9>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, 
-                   A8& a8, A9& a9) {
-    return function_adaptor<typename boost::remove_cv<A1>::type>::
-      template apply<RET>(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-  }
-};
-
-template<class T> class function_action<10, T> {
-public:
-  template<class RET, class A1, class A2, class A3, class A4, class A5, 
-           class A6, class A7, class A8, class A9, class A10>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, 
-                   A8& a8, A9& a9, A10& a10) {
-    return function_adaptor<typename boost::remove_cv<A1>::type>::
-      template apply<RET>(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
-  }
-};
-
-} // namespace lambda
-} // namespace boost
-
-#endif
diff --git a/contrib/restricted/boost/boost/lambda/detail/arity_code.hpp b/contrib/restricted/boost/boost/lambda/detail/arity_code.hpp
deleted file mode 100644
index bed34b9a4d..0000000000
--- a/contrib/restricted/boost/boost/lambda/detail/arity_code.hpp
+++ /dev/null
@@ -1,110 +0,0 @@
-// -- Boost Lambda Library -------------------------------------------------
-
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//
-// Distributed under 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)
-//
-// For more information, see www.boost.org
-
-// --------------------------------------------------
-
-#ifndef BOOST_LAMBDA_ARITY_CODE_HPP
-#define BOOST_LAMBDA_ARITY_CODE_HPP
-
-#include "boost/type_traits/cv_traits.hpp"
-#include "boost/type_traits/transform_traits.hpp"
-
-namespace boost { 
-namespace lambda {
-
-// These constants state, whether a lambda_functor instantiation results from 
-// an expression which contains no placeholders (NONE), 
-// only free1 placeholders (FIRST), 
-// free2 placeholders and maybe free1 placeholders (SECOND),
-// free3 and maybe free1 and free2 placeholders (THIRD),
-// freeE placeholders and maybe free1 and free2  (EXCEPTION).
-// RETHROW means, that a rethrow expression is used somewhere in the lambda_functor.
-
-enum { NONE             = 0x00, // Notice we are using bits as flags here.
-       FIRST            = 0x01, 
-       SECOND           = 0x02, 
-       THIRD            = 0x04, 
-       EXCEPTION        = 0x08, 
-       RETHROW          = 0x10};
-
-
-template<class T>
-struct get_tuple_arity;
-
-namespace detail {
-
-template <class T> struct get_arity_;
-
-} // end detail;
-
-template <class T> struct get_arity {
-
-  BOOST_STATIC_CONSTANT(int, value = detail::get_arity_<typename boost::remove_cv<typename boost::remove_reference<T>::type>::type>::value);
-
-};
-
-namespace detail {
-
-template<class T>
-struct get_arity_ {
-  BOOST_STATIC_CONSTANT(int, value = 0);
-};
-
-template<class T>
-struct get_arity_<lambda_functor<T> > {
-  BOOST_STATIC_CONSTANT(int, value = get_arity<T>::value);
-};
-
-template<class Action, class Args>
-struct get_arity_<lambda_functor_base<Action, Args> > {
-  BOOST_STATIC_CONSTANT(int, value = get_tuple_arity<Args>::value);
-};
-
-template<int I>
-struct get_arity_<placeholder<I> > {
-  BOOST_STATIC_CONSTANT(int, value = I);
-};
-
-} // detail 
-
-template<class T>
-struct get_tuple_arity {
-  BOOST_STATIC_CONSTANT(int, value = get_arity<typename T::head_type>::value | get_tuple_arity<typename T::tail_type>::value);
-};
-
-
-template<>
-struct get_tuple_arity<null_type> {
-  BOOST_STATIC_CONSTANT(int, value = 0);
-};
-
-
-  // Does T have placeholder<I> as it's subexpression?
-
-template<class T, int I>
-struct has_placeholder {
-  BOOST_STATIC_CONSTANT(bool, value = (get_arity<T>::value & I) != 0);
-}; 
-
-template<int I, int J>
-struct includes_placeholder {
-  BOOST_STATIC_CONSTANT(bool, value = (J & I) != 0);
-};
-
-template<int I, int J>
-struct lacks_placeholder {
-  BOOST_STATIC_CONSTANT(bool, value = ((J & I) == 0));
-};
-
-
-} // namespace lambda
-} // namespace boost
-
-#endif
diff --git a/contrib/restricted/boost/boost/lambda/detail/bind_functions.hpp b/contrib/restricted/boost/boost/lambda/detail/bind_functions.hpp
deleted file mode 100644
index f85513c091..0000000000
--- a/contrib/restricted/boost/boost/lambda/detail/bind_functions.hpp
+++ /dev/null
@@ -1,1879 +0,0 @@
-// -- bind_functions.hpp -- Boost Lambda Library
-//
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//
-// Distributed under 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)
-//
-// For more information, see http://www.boost.org
-
-// ----------------------------------------------------------------
-
-#ifndef BOOST_LAMBDA_BIND_FUNCTIONS_HPP
-#define BOOST_LAMBDA_BIND_FUNCTIONS_HPP
-
-
-namespace boost { 
-namespace lambda {
-
-#ifdef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING
-
-  // gcc 2.96 instantiates bind functions it does not even call.
-  // These instantiations lead to incorrect types in the return type, 
-  // and a compilation error results. 
-  // This tweaking is to prevent the formation of the erroneous type.
-namespace detail {
-
-template<class T> struct constify_non_funcs {
-  typedef typename 
-  detail::IF_type<boost::is_function<T>::value,
-    boost::add_reference<T>,
-    boost::add_const<T>
-  >::type type;
-};
-
-}
-#endif
-// 1-argument bind functions --------------------------
-#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
-template <class Result>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<1, function_action<1, Result> >,
-    typename detail::bind_tuple_mapper<Result(&)()>::type
-  >
->
-
-bind(Result(& a1)()) {
-  return
-    lambda_functor_base<
-      action<1, function_action<1, Result> >,
-      typename detail::bind_tuple_mapper<Result(&)()>::type
-    >
-    ( typename detail::bind_tuple_mapper<Result(&)()>::type
-      (a1)
-    );
-}
-#endif
-
- #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
-template <class Arg1>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<1, function_action<1> >,
-    typename detail::bind_tuple_mapper<const Arg1>::type
-  >
->
-
-bind(const Arg1& a1) {
-  return
-    lambda_functor_base<
-      action<1, function_action<1> >,
-      typename detail::bind_tuple_mapper<const Arg1>::type
-    >
-    ( typename detail::bind_tuple_mapper<const Arg1>::type
-      (a1)
-    );
-}
-
-template <class Result, class Arg1>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<1, function_action<1, Result> >,
-    typename detail::bind_tuple_mapper<const Arg1>::type
-  >
->
-
-bind(const Arg1& a1) {
-  return
-    lambda_functor_base<
-      action<1, function_action<1, Result> >,
-      typename detail::bind_tuple_mapper<const Arg1>::type
-    >
-    ( typename detail::bind_tuple_mapper<const Arg1>::type
-      (a1)
-    );
-}
-
-
- #else 
-template <class Arg1>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<1, function_action<1> >,
-    typename detail::bind_tuple_mapper<
-      typename detail::constify_non_funcs<Arg1>::type
-    >::type
-  >
->
-
-bind(const Arg1& a1) {
-  return
-    lambda_functor_base<
-      action<1, function_action<1> >,
-      typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type
-      >::type
-      (a1)
-    );
-}
-
-template <class Result, class Arg1>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<1, function_action<1, Result> >,
-    typename detail::bind_tuple_mapper<
-      typename detail::constify_non_funcs<Arg1>::type
-    >::type
-  >
->
-
-bind(const Arg1& a1) {
-  return
-    lambda_functor_base<
-      action<1, function_action<1, Result> >,
-      typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type
-      >::type
-      (a1)
-    );
-}
-
-template <class Result>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<1, function_action<1, Result> >,
-    typename detail::bind_tuple_mapper<Result(*)()>::type
-  >
->
-
-bind(Result(* const & a1)()) {
-  return
-    lambda_functor_base<
-      action<1, function_action<1, Result> >,
-      typename detail::bind_tuple_mapper<Result(*)()>::type
-    >
-    ( typename detail::bind_tuple_mapper<Result(*)()>::type
-      (a1)
-    );
-}
-
-
-#endif 
-
-// 2-argument bind functions --------------------------
-#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
-template <class Result, class Par1, class Arg2>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<2, function_action<2, Result> >,
-    typename detail::bind_tuple_mapper<Result(&)(Par1), const Arg2>::type
-  >
->
-
-bind(Result(&a1)(Par1), const Arg2& a2) {
-  return
-    lambda_functor_base<
-      action<2, function_action<2, Result> >,
-      typename detail::bind_tuple_mapper<Result(&)(Par1), const Arg2>::type
-    >
-    ( typename detail::bind_tuple_mapper<Result(&)(Par1), const Arg2>::type
-      (a1, a2)
-    );
-}
-#endif
-
-#ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
-template <class Arg1, class Arg2>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<2, function_action<2> >,
-    typename detail::bind_tuple_mapper<const Arg1, const Arg2>::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2) {
-  return
-    lambda_functor_base<
-      action<2, function_action<2> >,
-      typename detail::bind_tuple_mapper<const Arg1, const Arg2>::type
-    >
-    ( typename detail::bind_tuple_mapper<const Arg1, const Arg2>::type
-      (a1, a2)
-    );
-}
-
-template <class Result, class Arg1, class Arg2>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<2, function_action<2, Result> >,
-    typename detail::bind_tuple_mapper<const Arg1, const Arg2>::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2) {
-  return
-    lambda_functor_base<
-      action<2, function_action<2, Result> >,
-      typename detail::bind_tuple_mapper<const Arg1, const Arg2>::type
-    >
-    ( typename detail::bind_tuple_mapper<const Arg1, const Arg2>::type
-      (a1, a2)
-    );
-}
-
-
- #else 
-template <class Arg1, class Arg2>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<2, function_action<2> >,
-    typename detail::bind_tuple_mapper<
-      typename detail::constify_non_funcs<Arg1>::type, const Arg2
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2) {
-  return
-    lambda_functor_base<
-      action<2, function_action<2> >,
-      typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2
-      >::type
-      (a1, a2)
-    );
-}
-
-template <class Result, class Arg1, class Arg2>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<2, function_action<2, Result> >,
-    typename detail::bind_tuple_mapper<
-      typename detail::constify_non_funcs<Arg1>::type, const Arg2
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2) {
-  return
-    lambda_functor_base<
-      action<2, function_action<2, Result> >,
-      typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2
-      >::type
-      (a1, a2)
-    );
-}
-
-template <class Result, class Par1, class Arg2>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<2, function_action<2, Result> >,
-    typename detail::bind_tuple_mapper<Result(*)(Par1), const Arg2>::type
-  >
->
-
-bind(Result(* const & a1)(Par1), const Arg2& a2) {
-  return
-    lambda_functor_base<
-      action<2, function_action<2, Result> >,
-      typename detail::bind_tuple_mapper<Result(*)(Par1), const Arg2>::type
-    >
-    ( typename detail::bind_tuple_mapper<Result(*)(Par1), const Arg2>::type
-      (a1, a2)
-    );
-}
-
-
- #endif 
-
-// 3-argument bind functions --------------------------
-#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
-template <class Result, class Par1, class Par2, class Arg2, class Arg3>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<3, function_action<3, Result> >,
-    typename detail::bind_tuple_mapper<
-      Result(&)(Par1, Par2), const Arg2, const Arg3
-    >::type
-  >
->
-
-bind(Result(&a1)(Par1, Par2), const Arg2& a2, const Arg3& a3) {
-  return
-    lambda_functor_base<
-      action<3, function_action<3, Result> >,
-      typename detail::bind_tuple_mapper<
-        Result(&)(Par1, Par2), const Arg2, const Arg3
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        Result(&)(Par1, Par2), const Arg2, const Arg3
-      >::type
-      (a1, a2, a3)
-    );
-}
-#endif
-
- #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
-template <class Arg1, class Arg2, class Arg3>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<3, function_action<3> >,
-    typename detail::bind_tuple_mapper<
-      const Arg1, const Arg2, const Arg3
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3) {
-  return
-    lambda_functor_base<
-      action<3, function_action<3> >,
-      typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3
-      >::type
-      (a1, a2, a3)
-    );
-}
-
-template <class Result, class Arg1, class Arg2, class Arg3>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<3, function_action<3, Result> >,
-    typename detail::bind_tuple_mapper<
-      const Arg1, const Arg2, const Arg3
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3) {
-  return
-    lambda_functor_base<
-      action<3, function_action<3, Result> >,
-      typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3
-      >::type
-      (a1, a2, a3)
-    );
-}
-
-
- #else 
-template <class Arg1, class Arg2, class Arg3>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<3, function_action<3> >,
-    typename detail::bind_tuple_mapper<
-      typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3) {
-  return
-    lambda_functor_base<
-      action<3, function_action<3> >,
-      typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3
-      >::type
-      (a1, a2, a3)
-    );
-}
-
-template <class Result, class Arg1, class Arg2, class Arg3>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<3, function_action<3, Result> >,
-    typename detail::bind_tuple_mapper<
-      typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3) {
-  return
-    lambda_functor_base<
-      action<3, function_action<3, Result> >,
-      typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3
-      >::type
-      (a1, a2, a3)
-    );
-}
-
-template <class Result, class Par1, class Par2, class Arg2, class Arg3>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<3, function_action<3, Result> >,
-    typename detail::bind_tuple_mapper<
-      Result(*)(Par1, Par2), const Arg2, const Arg3
-    >::type
-  >
->
-
-bind(Result(* const & a1)(Par1, Par2), const Arg2& a2, const Arg3& a3) {
-  return
-    lambda_functor_base<
-      action<3, function_action<3, Result> >,
-      typename detail::bind_tuple_mapper<
-        Result(*)(Par1, Par2), const Arg2, const Arg3
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        Result(*)(Par1, Par2), const Arg2, const Arg3
-      >::type
-      (a1, a2, a3)
-    );
-}
-
-
- #endif 
-
-// 4-argument bind functions --------------------------
-#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
-template <class Result, class Par1, class Par2, class Par3, class Arg2,
-          class Arg3, class Arg4>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<4, function_action<4, Result> >,
-    typename detail::bind_tuple_mapper<
-      Result(&)(Par1, Par2, Par3), const Arg2, const Arg3, const Arg4
-    >::type
-  >
->
-
-bind(Result(&a1)(Par1, Par2, Par3), const Arg2& a2, const Arg3& a3,
-     const Arg4& a4) {
-  return
-    lambda_functor_base<
-      action<4, function_action<4, Result> >,
-      typename detail::bind_tuple_mapper<
-        Result(&)(Par1, Par2, Par3), const Arg2, const Arg3, const Arg4
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        Result(&)(Par1, Par2, Par3), const Arg2, const Arg3, const Arg4
-      >::type
-      (a1, a2, a3, a4)
-    );
-}
-#endif
-
- #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
-template <class Arg1, class Arg2, class Arg3, class Arg4>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<4, function_action<4> >,
-    typename detail::bind_tuple_mapper<
-      const Arg1, const Arg2, const Arg3, const Arg4
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4) {
-  return
-    lambda_functor_base<
-      action<4, function_action<4> >,
-      typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4
-      >::type
-      (a1, a2, a3, a4)
-    );
-}
-
-template <class Result, class Arg1, class Arg2, class Arg3, class Arg4>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<4, function_action<4, Result> >,
-    typename detail::bind_tuple_mapper<
-      const Arg1, const Arg2, const Arg3, const Arg4
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4) {
-  return
-    lambda_functor_base<
-      action<4, function_action<4, Result> >,
-      typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4
-      >::type
-      (a1, a2, a3, a4)
-    );
-}
-
-
- #else 
-template <class Arg1, class Arg2, class Arg3, class Arg4>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<4, function_action<4> >,
-    typename detail::bind_tuple_mapper<
-      typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3,
-      const Arg4
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4) {
-  return
-    lambda_functor_base<
-      action<4, function_action<4> >,
-      typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4
-      >::type
-      (a1, a2, a3, a4)
-    );
-}
-
-template <class Result, class Arg1, class Arg2, class Arg3, class Arg4>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<4, function_action<4, Result> >,
-    typename detail::bind_tuple_mapper<
-      typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3,
-      const Arg4
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4) {
-  return
-    lambda_functor_base<
-      action<4, function_action<4, Result> >,
-      typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4
-      >::type
-      (a1, a2, a3, a4)
-    );
-}
-
-template <class Result, class Par1, class Par2, class Par3, class Arg2,
-          class Arg3, class Arg4>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<4, function_action<4, Result> >,
-    typename detail::bind_tuple_mapper<
-      Result(*)(Par1, Par2, Par3), const Arg2, const Arg3, const Arg4
-    >::type
-  >
->
-
-bind(Result(* const & a1)(Par1, Par2, Par3), const Arg2& a2,
-     const Arg3& a3, const Arg4& a4) {
-  return
-    lambda_functor_base<
-      action<4, function_action<4, Result> >,
-      typename detail::bind_tuple_mapper<
-        Result(*)(Par1, Par2, Par3), const Arg2, const Arg3, const Arg4
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        Result(*)(Par1, Par2, Par3), const Arg2, const Arg3, const Arg4
-      >::type
-      (a1, a2, a3, a4)
-    );
-}
-
-
- #endif 
-
-// 5-argument bind functions --------------------------
-#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
-template <class Result, class Par1, class Par2, class Par3, class Par4,
-          class Arg2, class Arg3, class Arg4, class Arg5>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<5, function_action<5, Result> >,
-    typename detail::bind_tuple_mapper<
-      Result(&)(Par1, Par2, Par3, Par4), const Arg2, const Arg3, const Arg4,
-      const Arg5
-    >::type
-  >
->
-
-bind(Result(&a1)(Par1, Par2, Par3, Par4), const Arg2& a2, const Arg3& a3,
-     const Arg4& a4, const Arg5& a5) {
-  return
-    lambda_functor_base<
-      action<5, function_action<5, Result> >,
-      typename detail::bind_tuple_mapper<
-        Result(&)(Par1, Par2, Par3, Par4), const Arg2, const Arg3, const Arg4,
-        const Arg5
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        Result(&)(Par1, Par2, Par3, Par4), const Arg2, const Arg3, const Arg4,
-        const Arg5
-      >::type
-      (a1, a2, a3, a4, a5)
-    );
-}
-#endif
-
- #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<5, function_action<5> >,
-    typename detail::bind_tuple_mapper<
-      const Arg1, const Arg2, const Arg3, const Arg4, const Arg5
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4,
-     const Arg5& a5) {
-  return
-    lambda_functor_base<
-      action<5, function_action<5> >,
-      typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4, const Arg5
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4, const Arg5
-      >::type
-      (a1, a2, a3, a4, a5)
-    );
-}
-
-template <class Result, class Arg1, class Arg2, class Arg3, class Arg4,
-          class Arg5>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<5, function_action<5, Result> >,
-    typename detail::bind_tuple_mapper<
-      const Arg1, const Arg2, const Arg3, const Arg4, const Arg5
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4,
-     const Arg5& a5) {
-  return
-    lambda_functor_base<
-      action<5, function_action<5, Result> >,
-      typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4, const Arg5
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4, const Arg5
-      >::type
-      (a1, a2, a3, a4, a5)
-    );
-}
-
-
- #else 
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<5, function_action<5> >,
-    typename detail::bind_tuple_mapper<
-      typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3,
-      const Arg4, const Arg5
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4,
-     const Arg5& a5) {
-  return
-    lambda_functor_base<
-      action<5, function_action<5> >,
-      typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4, const Arg5
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4, const Arg5
-      >::type
-      (a1, a2, a3, a4, a5)
-    );
-}
-
-template <class Result, class Arg1, class Arg2, class Arg3, class Arg4,
-          class Arg5>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<5, function_action<5, Result> >,
-    typename detail::bind_tuple_mapper<
-      typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3,
-      const Arg4, const Arg5
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4,
-     const Arg5& a5) {
-  return
-    lambda_functor_base<
-      action<5, function_action<5, Result> >,
-      typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4, const Arg5
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4, const Arg5
-      >::type
-      (a1, a2, a3, a4, a5)
-    );
-}
-
-template <class Result, class Par1, class Par2, class Par3, class Par4,
-          class Arg2, class Arg3, class Arg4, class Arg5>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<5, function_action<5, Result> >,
-    typename detail::bind_tuple_mapper<
-      Result(*)(Par1, Par2, Par3, Par4), const Arg2, const Arg3, const Arg4,
-      const Arg5
-    >::type
-  >
->
-
-bind(Result(* const & a1)(Par1, Par2, Par3, Par4), const Arg2& a2,
-     const Arg3& a3, const Arg4& a4, const Arg5& a5) {
-  return
-    lambda_functor_base<
-      action<5, function_action<5, Result> >,
-      typename detail::bind_tuple_mapper<
-        Result(*)(Par1, Par2, Par3, Par4), const Arg2, const Arg3, const Arg4,
-        const Arg5
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        Result(*)(Par1, Par2, Par3, Par4), const Arg2, const Arg3, const Arg4,
-        const Arg5
-      >::type
-      (a1, a2, a3, a4, a5)
-    );
-}
-
-
- #endif 
-
-// 6-argument bind functions --------------------------
-#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
-template <class Result, class Par1, class Par2, class Par3, class Par4,
-          class Par5, class Arg2, class Arg3, class Arg4, class Arg5,
-          class Arg6>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<6, function_action<6, Result> >,
-    typename detail::bind_tuple_mapper<
-      Result(&)(Par1, Par2, Par3, Par4, Par5), const Arg2, const Arg3,
-      const Arg4, const Arg5, const Arg6
-    >::type
-  >
->
-
-bind(Result(&a1)(Par1, Par2, Par3, Par4, Par5), const Arg2& a2,
-     const Arg3& a3, const Arg4& a4, const Arg5& a5, const Arg6& a6) {
-  return
-    lambda_functor_base<
-      action<6, function_action<6, Result> >,
-      typename detail::bind_tuple_mapper<
-        Result(&)(Par1, Par2, Par3, Par4, Par5), const Arg2, const Arg3,
-        const Arg4, const Arg5, const Arg6
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        Result(&)(Par1, Par2, Par3, Par4, Par5), const Arg2, const Arg3,
-        const Arg4, const Arg5, const Arg6
-      >::type
-      (a1, a2, a3, a4, a5, a6)
-    );
-}
-#endif
-
- #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5,
-          class Arg6>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<6, function_action<6> >,
-    typename detail::bind_tuple_mapper<
-      const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4,
-     const Arg5& a5, const Arg6& a6) {
-  return
-    lambda_functor_base<
-      action<6, function_action<6> >,
-      typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6
-      >::type
-      (a1, a2, a3, a4, a5, a6)
-    );
-}
-
-template <class Result, class Arg1, class Arg2, class Arg3, class Arg4,
-          class Arg5, class Arg6>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<6, function_action<6, Result> >,
-    typename detail::bind_tuple_mapper<
-      const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4,
-     const Arg5& a5, const Arg6& a6) {
-  return
-    lambda_functor_base<
-      action<6, function_action<6, Result> >,
-      typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6
-      >::type
-      (a1, a2, a3, a4, a5, a6)
-    );
-}
-
-
- #else 
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5,
-          class Arg6>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<6, function_action<6> >,
-    typename detail::bind_tuple_mapper<
-      typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3,
-      const Arg4, const Arg5, const Arg6
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4,
-     const Arg5& a5, const Arg6& a6) {
-  return
-    lambda_functor_base<
-      action<6, function_action<6> >,
-      typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6
-      >::type
-      (a1, a2, a3, a4, a5, a6)
-    );
-}
-
-template <class Result, class Arg1, class Arg2, class Arg3, class Arg4,
-          class Arg5, class Arg6>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<6, function_action<6, Result> >,
-    typename detail::bind_tuple_mapper<
-      typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3,
-      const Arg4, const Arg5, const Arg6
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4,
-     const Arg5& a5, const Arg6& a6) {
-  return
-    lambda_functor_base<
-      action<6, function_action<6, Result> >,
-      typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6
-      >::type
-      (a1, a2, a3, a4, a5, a6)
-    );
-}
-
-template <class Result, class Par1, class Par2, class Par3, class Par4,
-          class Par5, class Arg2, class Arg3, class Arg4, class Arg5,
-          class Arg6>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<6, function_action<6, Result> >,
-    typename detail::bind_tuple_mapper<
-      Result(*)(Par1, Par2, Par3, Par4, Par5), const Arg2, const Arg3,
-      const Arg4, const Arg5, const Arg6
-    >::type
-  >
->
-
-bind(Result(* const & a1)(Par1, Par2, Par3, Par4, Par5), const Arg2& a2,
-     const Arg3& a3, const Arg4& a4, const Arg5& a5, const Arg6& a6) {
-  return
-    lambda_functor_base<
-      action<6, function_action<6, Result> >,
-      typename detail::bind_tuple_mapper<
-        Result(*)(Par1, Par2, Par3, Par4, Par5), const Arg2, const Arg3,
-        const Arg4, const Arg5, const Arg6
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        Result(*)(Par1, Par2, Par3, Par4, Par5), const Arg2, const Arg3,
-        const Arg4, const Arg5, const Arg6
-      >::type
-      (a1, a2, a3, a4, a5, a6)
-    );
-}
-
-
- #endif 
-
-// 7-argument bind functions --------------------------
-#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
-template <class Result, class Par1, class Par2, class Par3, class Par4,
-          class Par5, class Par6, class Arg2, class Arg3, class Arg4,
-          class Arg5, class Arg6, class Arg7>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<7, function_action<7, Result> >,
-    typename detail::bind_tuple_mapper<
-      Result(&)(Par1, Par2, Par3, Par4, Par5, Par6), const Arg2, const Arg3,
-      const Arg4, const Arg5, const Arg6, const Arg7
-    >::type
-  >
->
-
-bind(Result(&a1)(Par1, Par2, Par3, Par4, Par5, Par6), const Arg2& a2,
-     const Arg3& a3, const Arg4& a4, const Arg5& a5, const Arg6& a6,
-     const Arg7& a7) {
-  return
-    lambda_functor_base<
-      action<7, function_action<7, Result> >,
-      typename detail::bind_tuple_mapper<
-        Result(&)(Par1, Par2, Par3, Par4, Par5, Par6), const Arg2, const Arg3,
-        const Arg4, const Arg5, const Arg6, const Arg7
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        Result(&)(Par1, Par2, Par3, Par4, Par5, Par6), const Arg2, const Arg3,
-        const Arg4, const Arg5, const Arg6, const Arg7
-      >::type
-      (a1, a2, a3, a4, a5, a6, a7)
-    );
-}
-#endif
-
- #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5,
-          class Arg6, class Arg7>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<7, function_action<7> >,
-    typename detail::bind_tuple_mapper<
-      const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6,
-      const Arg7
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4,
-     const Arg5& a5, const Arg6& a6, const Arg7& a7) {
-  return
-    lambda_functor_base<
-      action<7, function_action<7> >,
-      typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4, const Arg5,
-        const Arg6, const Arg7
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4, const Arg5,
-        const Arg6, const Arg7
-      >::type
-      (a1, a2, a3, a4, a5, a6, a7)
-    );
-}
-
-template <class Result, class Arg1, class Arg2, class Arg3, class Arg4,
-          class Arg5, class Arg6, class Arg7>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<7, function_action<7, Result> >,
-    typename detail::bind_tuple_mapper<
-      const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6,
-      const Arg7
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4,
-     const Arg5& a5, const Arg6& a6, const Arg7& a7) {
-  return
-    lambda_functor_base<
-      action<7, function_action<7, Result> >,
-      typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4, const Arg5,
-        const Arg6, const Arg7
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4, const Arg5,
-        const Arg6, const Arg7
-      >::type
-      (a1, a2, a3, a4, a5, a6, a7)
-    );
-}
-
-
- #else 
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5,
-          class Arg6, class Arg7>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<7, function_action<7> >,
-    typename detail::bind_tuple_mapper<
-      typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3,
-      const Arg4, const Arg5, const Arg6, const Arg7
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4,
-     const Arg5& a5, const Arg6& a6, const Arg7& a7) {
-  return
-    lambda_functor_base<
-      action<7, function_action<7> >,
-      typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6, const Arg7
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6, const Arg7
-      >::type
-      (a1, a2, a3, a4, a5, a6, a7)
-    );
-}
-
-template <class Result, class Arg1, class Arg2, class Arg3, class Arg4,
-          class Arg5, class Arg6, class Arg7>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<7, function_action<7, Result> >,
-    typename detail::bind_tuple_mapper<
-      typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3,
-      const Arg4, const Arg5, const Arg6, const Arg7
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4,
-     const Arg5& a5, const Arg6& a6, const Arg7& a7) {
-  return
-    lambda_functor_base<
-      action<7, function_action<7, Result> >,
-      typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6, const Arg7
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6, const Arg7
-      >::type
-      (a1, a2, a3, a4, a5, a6, a7)
-    );
-}
-
-template <class Result, class Par1, class Par2, class Par3, class Par4,
-          class Par5, class Par6, class Arg2, class Arg3, class Arg4,
-          class Arg5, class Arg6, class Arg7>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<7, function_action<7, Result> >,
-    typename detail::bind_tuple_mapper<
-      Result(*)(Par1, Par2, Par3, Par4, Par5, Par6), const Arg2, const Arg3,
-      const Arg4, const Arg5, const Arg6, const Arg7
-    >::type
-  >
->
-
-bind(Result(* const & a1)(Par1, Par2, Par3, Par4, Par5, Par6),
-     const Arg2& a2, const Arg3& a3, const Arg4& a4, const Arg5& a5,
-     const Arg6& a6, const Arg7& a7) {
-  return
-    lambda_functor_base<
-      action<7, function_action<7, Result> >,
-      typename detail::bind_tuple_mapper<
-        Result(*)(Par1, Par2, Par3, Par4, Par5, Par6), const Arg2, const Arg3,
-        const Arg4, const Arg5, const Arg6, const Arg7
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        Result(*)(Par1, Par2, Par3, Par4, Par5, Par6), const Arg2, const Arg3,
-        const Arg4, const Arg5, const Arg6, const Arg7
-      >::type
-      (a1, a2, a3, a4, a5, a6, a7)
-    );
-}
-
-
- #endif 
-
-// 8-argument bind functions --------------------------
-#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
-template <class Result, class Par1, class Par2, class Par3, class Par4,
-          class Par5, class Par6, class Par7, class Arg2, class Arg3,
-          class Arg4, class Arg5, class Arg6, class Arg7, class Arg8>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<8, function_action<8, Result> >,
-    typename detail::bind_tuple_mapper<
-      Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7), const Arg2,
-      const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8
-    >::type
-  >
->
-
-bind(Result(&a1)(Par1, Par2, Par3, Par4, Par5, Par6, Par7), const Arg2& a2,
-     const Arg3& a3, const Arg4& a4, const Arg5& a5, const Arg6& a6,
-     const Arg7& a7, const Arg8& a8) {
-  return
-    lambda_functor_base<
-      action<8, function_action<8, Result> >,
-      typename detail::bind_tuple_mapper<
-        Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7), const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7), const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8
-      >::type
-      (a1, a2, a3, a4, a5, a6, a7, a8)
-    );
-}
-#endif
-
- #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5,
-          class Arg6, class Arg7, class Arg8>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<8, function_action<8> >,
-    typename detail::bind_tuple_mapper<
-      const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6,
-      const Arg7, const Arg8
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4,
-     const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8) {
-  return
-    lambda_functor_base<
-      action<8, function_action<8> >,
-      typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4, const Arg5,
-        const Arg6, const Arg7, const Arg8
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4, const Arg5,
-        const Arg6, const Arg7, const Arg8
-      >::type
-      (a1, a2, a3, a4, a5, a6, a7, a8)
-    );
-}
-
-template <class Result, class Arg1, class Arg2, class Arg3, class Arg4,
-          class Arg5, class Arg6, class Arg7, class Arg8>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<8, function_action<8, Result> >,
-    typename detail::bind_tuple_mapper<
-      const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6,
-      const Arg7, const Arg8
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4,
-     const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8) {
-  return
-    lambda_functor_base<
-      action<8, function_action<8, Result> >,
-      typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4, const Arg5,
-        const Arg6, const Arg7, const Arg8
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4, const Arg5,
-        const Arg6, const Arg7, const Arg8
-      >::type
-      (a1, a2, a3, a4, a5, a6, a7, a8)
-    );
-}
-
-
- #else 
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5,
-          class Arg6, class Arg7, class Arg8>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<8, function_action<8> >,
-    typename detail::bind_tuple_mapper<
-      typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3,
-      const Arg4, const Arg5, const Arg6, const Arg7, const Arg8
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4,
-     const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8) {
-  return
-    lambda_functor_base<
-      action<8, function_action<8> >,
-      typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8
-      >::type
-      (a1, a2, a3, a4, a5, a6, a7, a8)
-    );
-}
-
-template <class Result, class Arg1, class Arg2, class Arg3, class Arg4,
-          class Arg5, class Arg6, class Arg7, class Arg8>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<8, function_action<8, Result> >,
-    typename detail::bind_tuple_mapper<
-      typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3,
-      const Arg4, const Arg5, const Arg6, const Arg7, const Arg8
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4,
-     const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8) {
-  return
-    lambda_functor_base<
-      action<8, function_action<8, Result> >,
-      typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8
-      >::type
-      (a1, a2, a3, a4, a5, a6, a7, a8)
-    );
-}
-
-template <class Result, class Par1, class Par2, class Par3, class Par4,
-          class Par5, class Par6, class Par7, class Arg2, class Arg3,
-          class Arg4, class Arg5, class Arg6, class Arg7, class Arg8>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<8, function_action<8, Result> >,
-    typename detail::bind_tuple_mapper<
-      Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7), const Arg2,
-      const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8
-    >::type
-  >
->
-
-bind(Result(* const & a1)(Par1, Par2, Par3, Par4, Par5, Par6, Par7),
-     const Arg2& a2, const Arg3& a3, const Arg4& a4, const Arg5& a5,
-     const Arg6& a6, const Arg7& a7, const Arg8& a8) {
-  return
-    lambda_functor_base<
-      action<8, function_action<8, Result> >,
-      typename detail::bind_tuple_mapper<
-        Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7), const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7), const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8
-      >::type
-      (a1, a2, a3, a4, a5, a6, a7, a8)
-    );
-}
-
-
- #endif 
-
-// 9-argument bind functions --------------------------
-#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
-template <class Result, class Par1, class Par2, class Par3, class Par4,
-          class Par5, class Par6, class Par7, class Par8, class Arg2,
-          class Arg3, class Arg4, class Arg5, class Arg6, class Arg7,
-          class Arg8, class Arg9>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<9, function_action<9, Result> >,
-    typename detail::bind_tuple_mapper<
-      Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8), const Arg2,
-      const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8,
-      const Arg9
-    >::type
-  >
->
-
-bind(Result(&a1)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8),
-     const Arg2& a2, const Arg3& a3, const Arg4& a4, const Arg5& a5,
-     const Arg6& a6, const Arg7& a7, const Arg8& a8, const Arg9& a9) {
-  return
-    lambda_functor_base<
-      action<9, function_action<9, Result> >,
-      typename detail::bind_tuple_mapper<
-        Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8), const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6, const Arg7,
-        const Arg8, const Arg9
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8), const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6, const Arg7,
-        const Arg8, const Arg9
-      >::type
-      (a1, a2, a3, a4, a5, a6, a7, a8, a9)
-    );
-}
-#endif
-
- #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5,
-          class Arg6, class Arg7, class Arg8, class Arg9>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<9, function_action<9> >,
-    typename detail::bind_tuple_mapper<
-      const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6,
-      const Arg7, const Arg8, const Arg9
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4,
-     const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8,
-     const Arg9& a9) {
-  return
-    lambda_functor_base<
-      action<9, function_action<9> >,
-      typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4, const Arg5,
-        const Arg6, const Arg7, const Arg8, const Arg9
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4, const Arg5,
-        const Arg6, const Arg7, const Arg8, const Arg9
-      >::type
-      (a1, a2, a3, a4, a5, a6, a7, a8, a9)
-    );
-}
-
-template <class Result, class Arg1, class Arg2, class Arg3, class Arg4,
-          class Arg5, class Arg6, class Arg7, class Arg8, class Arg9>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<9, function_action<9, Result> >,
-    typename detail::bind_tuple_mapper<
-      const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6,
-      const Arg7, const Arg8, const Arg9
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4,
-     const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8,
-     const Arg9& a9) {
-  return
-    lambda_functor_base<
-      action<9, function_action<9, Result> >,
-      typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4, const Arg5,
-        const Arg6, const Arg7, const Arg8, const Arg9
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4, const Arg5,
-        const Arg6, const Arg7, const Arg8, const Arg9
-      >::type
-      (a1, a2, a3, a4, a5, a6, a7, a8, a9)
-    );
-}
-
-
- #else 
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5,
-          class Arg6, class Arg7, class Arg8, class Arg9>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<9, function_action<9> >,
-    typename detail::bind_tuple_mapper<
-      typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3,
-      const Arg4, const Arg5, const Arg6, const Arg7, const Arg8, const Arg9
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4,
-     const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8,
-     const Arg9& a9) {
-  return
-    lambda_functor_base<
-      action<9, function_action<9> >,
-      typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6, const Arg7,
-        const Arg8, const Arg9
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6, const Arg7,
-        const Arg8, const Arg9
-      >::type
-      (a1, a2, a3, a4, a5, a6, a7, a8, a9)
-    );
-}
-
-template <class Result, class Arg1, class Arg2, class Arg3, class Arg4,
-          class Arg5, class Arg6, class Arg7, class Arg8, class Arg9>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<9, function_action<9, Result> >,
-    typename detail::bind_tuple_mapper<
-      typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3,
-      const Arg4, const Arg5, const Arg6, const Arg7, const Arg8, const Arg9
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4,
-     const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8,
-     const Arg9& a9) {
-  return
-    lambda_functor_base<
-      action<9, function_action<9, Result> >,
-      typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6, const Arg7,
-        const Arg8, const Arg9
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6, const Arg7,
-        const Arg8, const Arg9
-      >::type
-      (a1, a2, a3, a4, a5, a6, a7, a8, a9)
-    );
-}
-
-template <class Result, class Par1, class Par2, class Par3, class Par4,
-          class Par5, class Par6, class Par7, class Par8, class Arg2,
-          class Arg3, class Arg4, class Arg5, class Arg6, class Arg7,
-          class Arg8, class Arg9>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<9, function_action<9, Result> >,
-    typename detail::bind_tuple_mapper<
-      Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8), const Arg2,
-      const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8,
-      const Arg9
-    >::type
-  >
->
-
-bind(Result(* const & a1)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8),
-     const Arg2& a2, const Arg3& a3, const Arg4& a4, const Arg5& a5,
-     const Arg6& a6, const Arg7& a7, const Arg8& a8, const Arg9& a9) {
-  return
-    lambda_functor_base<
-      action<9, function_action<9, Result> >,
-      typename detail::bind_tuple_mapper<
-        Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8), const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6, const Arg7,
-        const Arg8, const Arg9
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8), const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6, const Arg7,
-        const Arg8, const Arg9
-      >::type
-      (a1, a2, a3, a4, a5, a6, a7, a8, a9)
-    );
-}
-
-
- #endif 
-
-// 10-argument bind functions --------------------------
-#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
-template <class Result, class Par1, class Par2, class Par3, class Par4,
-          class Par5, class Par6, class Par7, class Par8, class Par9,
-          class Arg2, class Arg3, class Arg4, class Arg5, class Arg6,
-          class Arg7, class Arg8, class Arg9, class Arg10>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<10, function_action<10, Result> >,
-    typename detail::bind_tuple_mapper<
-      Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8, Par9),
-      const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, const Arg7,
-      const Arg8, const Arg9, const Arg10
-    >::type
-  >
->
-
-bind(Result(&a1)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8, Par9),
-     const Arg2& a2, const Arg3& a3, const Arg4& a4, const Arg5& a5,
-     const Arg6& a6, const Arg7& a7, const Arg8& a8, const Arg9& a9,
-     const Arg10& a10) {
-  return
-    lambda_functor_base<
-      action<10, function_action<10, Result> >,
-      typename detail::bind_tuple_mapper<
-        Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8, Par9),
-        const Arg2, const Arg3, const Arg4, const Arg5, const Arg6,
-        const Arg7, const Arg8, const Arg9, const Arg10
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8, Par9),
-        const Arg2, const Arg3, const Arg4, const Arg5, const Arg6,
-        const Arg7, const Arg8, const Arg9, const Arg10
-      >::type
-      (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
-    );
-}
-#endif
-
- #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING 
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5,
-          class Arg6, class Arg7, class Arg8, class Arg9, class Arg10>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<10, function_action<10> >,
-    typename detail::bind_tuple_mapper<
-      const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6,
-      const Arg7, const Arg8, const Arg9, const Arg10
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4,
-     const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8,
-     const Arg9& a9, const Arg10& a10) {
-  return
-    lambda_functor_base<
-      action<10, function_action<10> >,
-      typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4, const Arg5,
-        const Arg6, const Arg7, const Arg8, const Arg9, const Arg10
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4, const Arg5,
-        const Arg6, const Arg7, const Arg8, const Arg9, const Arg10
-      >::type
-      (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
-    );
-}
-
-template <class Result, class Arg1, class Arg2, class Arg3, class Arg4,
-          class Arg5, class Arg6, class Arg7, class Arg8, class Arg9,
-          class Arg10>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<10, function_action<10, Result> >,
-    typename detail::bind_tuple_mapper<
-      const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6,
-      const Arg7, const Arg8, const Arg9, const Arg10
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4,
-     const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8,
-     const Arg9& a9, const Arg10& a10) {
-  return
-    lambda_functor_base<
-      action<10, function_action<10, Result> >,
-      typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4, const Arg5,
-        const Arg6, const Arg7, const Arg8, const Arg9, const Arg10
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        const Arg1, const Arg2, const Arg3, const Arg4, const Arg5,
-        const Arg6, const Arg7, const Arg8, const Arg9, const Arg10
-      >::type
-      (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
-    );
-}
-
-
- #else 
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5,
-          class Arg6, class Arg7, class Arg8, class Arg9, class Arg10>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<10, function_action<10> >,
-    typename detail::bind_tuple_mapper<
-      typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3,
-      const Arg4, const Arg5, const Arg6, const Arg7, const Arg8, const Arg9,
-      const Arg10
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4,
-     const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8,
-     const Arg9& a9, const Arg10& a10) {
-  return
-    lambda_functor_base<
-      action<10, function_action<10> >,
-      typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6, const Arg7,
-        const Arg8, const Arg9, const Arg10
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6, const Arg7,
-        const Arg8, const Arg9, const Arg10
-      >::type
-      (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
-    );
-}
-
-template <class Result, class Arg1, class Arg2, class Arg3, class Arg4,
-          class Arg5, class Arg6, class Arg7, class Arg8, class Arg9,
-          class Arg10>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<10, function_action<10, Result> >,
-    typename detail::bind_tuple_mapper<
-      typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3,
-      const Arg4, const Arg5, const Arg6, const Arg7, const Arg8, const Arg9,
-      const Arg10
-    >::type
-  >
->
-
-bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4,
-     const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8,
-     const Arg9& a9, const Arg10& a10) {
-  return
-    lambda_functor_base<
-      action<10, function_action<10, Result> >,
-      typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6, const Arg7,
-        const Arg8, const Arg9, const Arg10
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        typename detail::constify_non_funcs<Arg1>::type, const Arg2,
-        const Arg3, const Arg4, const Arg5, const Arg6, const Arg7,
-        const Arg8, const Arg9, const Arg10
-      >::type
-      (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
-    );
-}
-
-template <class Result, class Par1, class Par2, class Par3, class Par4,
-          class Par5, class Par6, class Par7, class Par8, class Par9,
-          class Arg2, class Arg3, class Arg4, class Arg5, class Arg6,
-          class Arg7, class Arg8, class Arg9, class Arg10>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<10, function_action<10, Result> >,
-    typename detail::bind_tuple_mapper<
-      Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8, Par9),
-      const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, const Arg7,
-      const Arg8, const Arg9, const Arg10
-    >::type
-  >
->
-
-bind(Result(* const & a1)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8,
-     Par9), const Arg2& a2, const Arg3& a3, const Arg4& a4, const Arg5& a5,
-     const Arg6& a6, const Arg7& a7, const Arg8& a8, const Arg9& a9,
-     const Arg10& a10) {
-  return
-    lambda_functor_base<
-      action<10, function_action<10, Result> >,
-      typename detail::bind_tuple_mapper<
-        Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8, Par9),
-        const Arg2, const Arg3, const Arg4, const Arg5, const Arg6,
-        const Arg7, const Arg8, const Arg9, const Arg10
-      >::type
-    >
-    ( typename detail::bind_tuple_mapper<
-        Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8, Par9),
-        const Arg2, const Arg3, const Arg4, const Arg5, const Arg6,
-        const Arg7, const Arg8, const Arg9, const Arg10
-      >::type
-      (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
-    );
-}
-
-
- #endif 
-
-} // namespace lambda 
-} // namespace boost
-
-#endif
diff --git a/contrib/restricted/boost/boost/lambda/detail/control_constructs_common.hpp b/contrib/restricted/boost/boost/lambda/detail/control_constructs_common.hpp
deleted file mode 100644
index 68265816bc..0000000000
--- a/contrib/restricted/boost/boost/lambda/detail/control_constructs_common.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-// Boost Lambda Library -- control_constructs_common.hpp -------------------
-
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2000 Gary Powell (powellg@amazon.com)
-//
-// Distributed under 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)
-//
-// For more information, see www.boost.org
-
-// --------------------------------------------------------------------------
-
-#if !defined(BOOST_CONTROL_CONSTRUCTS_COMMON_HPP)
-#define BOOST_CONTROL_CONSTRUCTS_COMMON_HPP
-
-namespace boost { 
-namespace lambda {
-
-  // special types of lambda functors, used with control structures
-  // to guarantee that they are composed correctly.
-
-template<class Tag, class LambdaFunctor>
-class tagged_lambda_functor;
-
-template<class Tag, class Args>
-class tagged_lambda_functor<Tag, lambda_functor<Args> > 
-  : public lambda_functor<Args> 
-{
-public:
-  tagged_lambda_functor(const Args& a) : lambda_functor<Args>(a) {}
-
-  tagged_lambda_functor(const lambda_functor<Args>& a) 
-    : lambda_functor<Args>(a) {}
-
-  // for the no body cases in control structures.
-  tagged_lambda_functor() : lambda_functor<Args>() {}
-};
-
-} // lambda
-} // boost
-
-#endif // BOOST_CONTROL_CONSTRUCTS_COMMON_HPP
-
-
-
-
-
-
-
diff --git a/contrib/restricted/boost/boost/lambda/detail/function_adaptors.hpp b/contrib/restricted/boost/boost/lambda/detail/function_adaptors.hpp
deleted file mode 100644
index 35db8b4304..0000000000
--- a/contrib/restricted/boost/boost/lambda/detail/function_adaptors.hpp
+++ /dev/null
@@ -1,789 +0,0 @@
-// Boost Lambda Library -  function_adaptors.hpp ----------------------------
- 
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//
-// Distributed under 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)
-//
-// For more information, see www.boost.org
-
-
-#ifndef BOOST_LAMBDA_FUNCTION_ADAPTORS_HPP
-#define BOOST_LAMBDA_FUNCTION_ADAPTORS_HPP
-
-#include "boost/mpl/has_xxx.hpp"
-#include "boost/tuple/tuple.hpp"
-#include "boost/type_traits/same_traits.hpp"
-#include "boost/type_traits/remove_reference.hpp"
-#include "boost/type_traits/remove_cv.hpp"
-#include "boost/type_traits/add_const.hpp"
-#include "boost/type_traits/add_volatile.hpp"
-#include "boost/utility/result_of.hpp"
-
-namespace boost { 
-namespace lambda {
-
-namespace detail {
-
-BOOST_MPL_HAS_XXX_TEMPLATE_DEF(sig)
-
-template<class Tuple>
-struct remove_references_from_elements {
-  typedef typename boost::tuples::cons<
-    typename boost::remove_reference<typename Tuple::head_type>::type,
-    typename remove_references_from_elements<typename Tuple::tail_type>::type
-  > type;
-};
-
-template<>
-struct remove_references_from_elements<boost::tuples::null_type> {
-  typedef boost::tuples::null_type type;
-};
-
-}
-
-template <class Func> struct function_adaptor {
-
-  typedef typename detail::remove_reference_and_cv<Func>::type plainF;
-
-#if !defined(BOOST_NO_RESULT_OF)
-  // Support functors that use the boost::result_of return type convention.
-  template<class Tuple, int Length, bool HasSig>
-  struct result_converter;
-  template<class Tuple, int Length>
-  struct result_converter<Tuple, Length, true>
-    : plainF::template sig<
-        typename detail::remove_references_from_elements<Tuple>::type
-      >
-  {};
-  template<class Tuple>
-  struct result_converter<Tuple, 0, false>
-    : result_of<plainF()>
-  {};
-  template<class Tuple>
-  struct result_converter<Tuple, 1, false>
-    : result_of<plainF(
-        typename tuples::element<1, Tuple>::type)
-      >
-  {};
-  template<class Tuple>
-  struct result_converter<Tuple, 2, false>
-    : result_of<plainF(
-        typename tuples::element<1, Tuple>::type,
-        typename tuples::element<2, Tuple>::type)
-      >
-  {};
-  template<class Tuple>
-  struct result_converter<Tuple, 3, false>
-    : result_of<plainF(
-        typename tuples::element<1, Tuple>::type,
-        typename tuples::element<2, Tuple>::type,
-        typename tuples::element<3, Tuple>::type)
-      >
-  {};
-  template<class Tuple>
-  struct result_converter<Tuple, 4, false>
-    : result_of<plainF(
-        typename tuples::element<1, Tuple>::type,
-        typename tuples::element<2, Tuple>::type,
-        typename tuples::element<3, Tuple>::type,
-        typename tuples::element<4, Tuple>::type)
-      >
-  {};
-  template<class Tuple>
-  struct result_converter<Tuple, 5, false>
-    : result_of<plainF(
-        typename tuples::element<1, Tuple>::type,
-        typename tuples::element<2, Tuple>::type,
-        typename tuples::element<3, Tuple>::type,
-        typename tuples::element<4, Tuple>::type,
-        typename tuples::element<5, Tuple>::type)
-      >
-  {};
-  template<class Tuple>
-  struct result_converter<Tuple, 6, false>
-    : result_of<plainF(
-        typename tuples::element<1, Tuple>::type,
-        typename tuples::element<2, Tuple>::type,
-        typename tuples::element<3, Tuple>::type,
-        typename tuples::element<4, Tuple>::type,
-        typename tuples::element<5, Tuple>::type,
-        typename tuples::element<6, Tuple>::type)
-      >
-  {};
-  template<class Tuple>
-  struct result_converter<Tuple, 7, false>
-    : result_of<plainF(
-        typename tuples::element<1, Tuple>::type,
-        typename tuples::element<2, Tuple>::type,
-        typename tuples::element<3, Tuple>::type,
-        typename tuples::element<4, Tuple>::type,
-        typename tuples::element<5, Tuple>::type,
-        typename tuples::element<6, Tuple>::type,
-        typename tuples::element<7, Tuple>::type)
-      >
-  {};
-  template<class Tuple>
-  struct result_converter<Tuple, 8, false>
-    : result_of<plainF(
-        typename tuples::element<1, Tuple>::type,
-        typename tuples::element<2, Tuple>::type,
-        typename tuples::element<3, Tuple>::type,
-        typename tuples::element<4, Tuple>::type,
-        typename tuples::element<5, Tuple>::type,
-        typename tuples::element<6, Tuple>::type,
-        typename tuples::element<7, Tuple>::type,
-        typename tuples::element<8, Tuple>::type)
-      >
-  {};
-  template<class Tuple>
-  struct result_converter<Tuple, 9, false>
-    : result_of<plainF(
-        typename tuples::element<1, Tuple>::type,
-        typename tuples::element<2, Tuple>::type,
-        typename tuples::element<3, Tuple>::type,
-        typename tuples::element<4, Tuple>::type,
-        typename tuples::element<5, Tuple>::type,
-        typename tuples::element<6, Tuple>::type,
-        typename tuples::element<7, Tuple>::type,
-        typename tuples::element<8, Tuple>::type,
-        typename tuples::element<9, Tuple>::type)
-      >
-  {};
-
-  // we do not know the return type off-hand, we must ask it from Func
-  // To sig we pass a cons list, where the head is the function object type
-  // itself (potentially cv-qualified)
-  // and the tail contains the types of the actual arguments to be passed
-  // to the function object. The arguments can be cv qualified
-  // as well.
-  template <class Args>
-  struct sig
-    : result_converter<
-        Args
-      , tuples::length<typename Args::tail_type>::value
-      , detail::has_sig<plainF>::value
-      >
-  {};
-#else // BOOST_NO_RESULT_OF
-
-  template <class Args> class sig {
-    typedef typename detail::remove_reference_and_cv<Func>::type plainF;
-  public:
-    typedef typename plainF::template sig<
-      typename detail::remove_references_from_elements<Args>::type
-    >::type type;
-  };
-#endif
-
-  template<class RET, class A1>
-  static RET apply(A1& a1) {
-    return a1();
-  }
-  template<class RET, class A1, class A2>
-  static RET apply(A1& a1, A2& a2) {
-    return a1(a2);
-  }
-  template<class RET, class A1, class A2, class A3>
-  static RET apply(A1& a1, A2& a2, A3& a3) {
-    return a1(a2, a3);
-  }
-  template<class RET, class A1, class A2, class A3, class A4>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4) {
-    return a1(a2, a3, a4);
-  }
-  template<class RET, class A1, class A2, class A3, class A4, class A5>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
-    return a1(a2, a3, a4, a5);
-  }
-  template<class RET, class A1, class A2, class A3, class A4, class A5, class A6>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
-    return a1(a2, a3, a4, a5, a6);
-  }
-  template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, 
-           class A7>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, 
-                           A7& a7) {
-    return a1(a2, a3, a4, a5, a6, a7);
-  }
-  template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, 
-           class A7, class A8>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, 
-                           A7& a7, A8& a8) {
-    return a1(a2, a3, a4, a5, a6, a7, a8);
-  }
-  template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, 
-           class A7, class A8, class A9>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, 
-                           A7& a7, A8& a8, A9& a9) {
-    return a1(a2, a3, a4, a5, a6, a7, a8, a9);
-  }
-  template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, 
-           class A7, class A8, class A9, class A10>
-  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, 
-                           A7& a7, A8& a8, A9& a9, A10& a10) {
-    return a1(a2, a3, a4, a5, a6, a7, a8, a9, a10);
-  }
-};
-
-template <class Func> struct function_adaptor<const Func>; // error 
-
-// -- function adaptors with data member access
-template <class Object, class T>
-struct function_adaptor<T Object::*> {
-
-  //  typedef detail::unspecified type;
-
-  // T can have qualifiers and can be a reference type
-  // We get the return type by adding const, if the object through which
-  // the data member is accessed is const, and finally adding a reference
-  template<class Args> class sig { 
-    typedef typename boost::tuples::element<1, Args>::type argument_type;
-    typedef typename boost::remove_reference<
-      argument_type
-    >::type unref_type;
-
-    typedef typename detail::IF<boost::is_const<unref_type>::value,
-      typename boost::add_const<T>::type,
-      T
-    >::RET properly_consted_return_type;
-
-    typedef typename detail::IF<boost::is_volatile<unref_type>::value,
-      typename boost::add_volatile<properly_consted_return_type>::type,
-      properly_consted_return_type
-    >::RET properly_cvd_return_type;
-
-
-  public:
-    typedef typename detail::IF<boost::is_reference<argument_type>::value,
-      typename boost::add_reference<properly_cvd_return_type>::type,
-      typename boost::remove_cv<T>::type
-    >::RET type;
-  };
-
-  template <class RET>
-  static RET apply( T Object::*data, Object& o) {
-    return o.*data;
-  }
-  template <class RET>
-  static RET apply( T Object::*data, const Object& o) {
-    return o.*data;
-  }
-  template <class RET>
-  static RET apply( T Object::*data, volatile Object& o) {
-    return o.*data;
-  }
-  template <class RET>
-  static RET apply( T Object::*data, const volatile Object& o) {
-    return o.*data;
-  }
-  template <class RET>
-  static RET apply( T Object::*data, Object* o) {
-    return o->*data;
-  }
-  template <class RET>
-  static RET apply( T Object::*data, const Object* o) {
-    return o->*data;
-  }
-  template <class RET>
-  static RET apply( T Object::*data, volatile Object* o) {
-    return o->*data;
-  }
-  template <class RET>
-  static RET apply( T Object::*data, const volatile Object* o) {
-    return o->*data;
-  }
-};
-
-// -- function adaptors with 1 argument apply
-   
-template <class Result>
-struct function_adaptor<Result (void)> {
-  
-  template<class T> struct sig { typedef Result type; };
-  template <class RET>
-  static Result apply(Result (*func)()) {
-    return func();
-  }
-};
-
-template <class Result>
-struct function_adaptor<Result (*)(void)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET>
-  static Result apply(Result (*func)()) {
-    return func();
-  }
-};
-
-
-// -- function adaptors with 2 argument apply
-template <class Object, class Result>
-struct function_adaptor<Result (Object::*)() const> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET>
-  static Result apply( Result (Object::*func)() const, const Object* o) {
-    return (o->*func)();
-  }
-  template <class RET>
-  static Result apply( Result (Object::*func)() const, const Object& o) {
-    return (o.*func)();
-  }
-};
-
-template <class Object, class Result>
-struct function_adaptor<Result (Object::*)()> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET>
-  static Result apply( Result (Object::*func)(), Object* o) {
-    return (o->*func)();
-  }
-  template <class RET>
-  static Result apply( Result (Object::*func)(), Object& o) {
-    return (o.*func)();
-  }
-};
-
-template <class Arg1, class Result>
-struct function_adaptor<Result (Arg1)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1>
-  static Result apply(Result (*func)(Arg1), A1& a1) {
-    return func(a1);
-  }
-};
-
-template <class Arg1, class Result>
-struct function_adaptor<Result (*)(Arg1)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1>
-  static Result apply(Result (*func)(Arg1), A1& a1) {
-    return func(a1);
-  }
-};
-
-
-// -- function adaptors with 3 argument apply
-template <class Object, class Arg1, class Result>
-struct function_adaptor<Result (Object::*)(Arg1) const> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1>
-  static Result apply( Result (Object::*func)(Arg1) const, const Object* o, 
-    A1& a1) {
-    return (o->*func)(a1);
-  }
-  template <class RET, class A1>
-  static Result apply( Result (Object::*func)(Arg1) const, const Object& o, 
-    A1& a1) {
-    return (o.*func)(a1);
-  }
-};
-
-template <class Object, class Arg1, class Result>
-struct function_adaptor<Result (Object::*)(Arg1)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1>
-  static Result apply( Result (Object::*func)(Arg1), Object* o, A1& a1) {
-    return (o->*func)(a1);
-  }
-  template <class RET, class A1>
-  static Result apply( Result (Object::*func)(Arg1), Object& o, A1& a1) {
-    return (o.*func)(a1);
-  }
-};
-
-template <class Arg1, class Arg2, class Result>
-struct function_adaptor<Result (Arg1, Arg2)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2>
-  static Result apply(Result (*func)(Arg1, Arg2), A1& a1, A2& a2) {
-    return func(a1, a2);
-  }
-};
-
-template <class Arg1, class Arg2, class Result>
-struct function_adaptor<Result (*)(Arg1, Arg2)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2>
-  static Result apply(Result (*func)(Arg1, Arg2), A1& a1, A2& a2) {
-    return func(a1, a2);
-  }
-};
-
-
-// -- function adaptors with 4 argument apply
-template <class Object, class Arg1, class Arg2, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2) const> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2>
-  static Result apply( Result (Object::*func)(Arg1, Arg2) const, const Object* o, A1& a1, A2& a2) {
-    return (o->*func)(a1, a2);
-  }
-  template <class RET, class A1, class A2>
-  static Result apply( Result (Object::*func)(Arg1, Arg2) const, const Object& o, A1& a1, A2& a2) {
-    return (o.*func)(a1, a2);
-  }
-};
-
-template <class Object, class Arg1, class Arg2, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2>
-  static Result apply( Result (Object::*func)(Arg1, Arg2), Object* o, A1& a1, A2& a2) {
-    return (o->*func)(a1, a2);
-  }
-  template <class RET, class A1, class A2>
-  static Result apply( Result (Object::*func)(Arg1, Arg2), Object& o, A1& a1, A2& a2) {
-    return (o.*func)(a1, a2);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Result>
-struct function_adaptor<Result (Arg1, Arg2, Arg3)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3), A1& a1, A2& a2, A3& a3) {
-    return func(a1, a2, a3);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Result>
-struct function_adaptor<Result (*)(Arg1, Arg2, Arg3)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3), A1& a1, A2& a2, A3& a3) {
-    return func(a1, a2, a3);
-  }
-};
-
-
-// -- function adaptors with 5 argument apply
-template <class Object, class Arg1, class Arg2, class Arg3, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3) const> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3) const, const Object* o, A1& a1, A2& a2, A3& a3) {
-    return (o->*func)(a1, a2, a3);
-  }
-  template <class RET, class A1, class A2, class A3>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3) const, const Object& o, A1& a1, A2& a2, A3& a3) {
-    return (o.*func)(a1, a2, a3);
-  }
-};
-
-template <class Object, class Arg1, class Arg2, class Arg3, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3), Object* o, A1& a1, A2& a2, A3& a3) {
-    return (o->*func)(a1, a2, a3);
-  }
-  template <class RET, class A1, class A2, class A3>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3), Object& o, A1& a1, A2& a2, A3& a3) {
-    return (o.*func)(a1, a2, a3);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Result>
-struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4), A1& a1, A2& a2, A3& a3, A4& a4) {
-    return func(a1, a2, a3, a4);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Result>
-struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4), A1& a1, A2& a2, A3& a3, A4& a4) {
-    return func(a1, a2, a3, a4);
-  }
-};
-
-
-// -- function adaptors with 6 argument apply
-template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4) const> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4) {
-    return (o->*func)(a1, a2, a3, a4);
-  }
-  template <class RET, class A1, class A2, class A3, class A4>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4) {
-    return (o.*func)(a1, a2, a3, a4);
-  }
-};
-
-template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4), Object* o, A1& a1, A2& a2, A3& a3, A4& a4) {
-    return (o->*func)(a1, a2, a3, a4);
-  }
-  template <class RET, class A1, class A2, class A3, class A4>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4), Object& o, A1& a1, A2& a2, A3& a3, A4& a4) {
-    return (o.*func)(a1, a2, a3, a4);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
-struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
-    return func(a1, a2, a3, a4, a5);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
-struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
-    return func(a1, a2, a3, a4, a5);
-  }
-};
-
-
-// -- function adaptors with 7 argument apply
-template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5) const> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
-    return (o->*func)(a1, a2, a3, a4, a5);
-  }
-  template <class RET, class A1, class A2, class A3, class A4, class A5>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
-    return (o.*func)(a1, a2, a3, a4, a5);
-  }
-};
-
-template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
-    return (o->*func)(a1, a2, a3, a4, a5);
-  }
-  template <class RET, class A1, class A2, class A3, class A4, class A5>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
-    return (o.*func)(a1, a2, a3, a4, a5);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
-struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
-    return func(a1, a2, a3, a4, a5, a6);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
-struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
-    return func(a1, a2, a3, a4, a5, a6);
-  }
-};
-
-
-// -- function adaptors with 8 argument apply
-template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) const> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
-    return (o->*func)(a1, a2, a3, a4, a5, a6);
-  }
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
-    return (o.*func)(a1, a2, a3, a4, a5, a6);
-  }
-};
-
-template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
-    return (o->*func)(a1, a2, a3, a4, a5, a6);
-  }
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
-    return (o.*func)(a1, a2, a3, a4, a5, a6);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
-struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
-    return func(a1, a2, a3, a4, a5, a6, a7);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
-struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
-    return func(a1, a2, a3, a4, a5, a6, a7);
-  }
-};
-
-
-// -- function adaptors with 9 argument apply
-template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) const> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
-    return (o->*func)(a1, a2, a3, a4, a5, a6, a7);
-  }
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
-    return (o.*func)(a1, a2, a3, a4, a5, a6, a7);
-  }
-};
-
-template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
-    return (o->*func)(a1, a2, a3, a4, a5, a6, a7);
-  }
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
-    return (o.*func)(a1, a2, a3, a4, a5, a6, a7);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
-struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {
-    return func(a1, a2, a3, a4, a5, a6, a7, a8);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
-struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {
-    return func(a1, a2, a3, a4, a5, a6, a7, a8);
-  }
-};
-
-
-// -- function adaptors with 10 argument apply
-template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) const> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {
-    return (o->*func)(a1, a2, a3, a4, a5, a6, a7, a8);
-  }
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {
-    return (o.*func)(a1, a2, a3, a4, a5, a6, a7, a8);
-  }
-};
-
-template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
-struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {
-    return (o->*func)(a1, a2, a3, a4, a5, a6, a7, a8);
-  }
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {
-    return (o.*func)(a1, a2, a3, a4, a5, a6, a7, a8);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9, class Result>
-struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) {
-    return func(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-  }
-};
-
-template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9, class Result>
-struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)> {
-
-  template<class T> struct sig { typedef Result type; };
-  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) {
-    return func(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-  }
-};
-
-} // namespace lambda
-} // namespace boost
-
-#endif
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/contrib/restricted/boost/boost/lambda/detail/is_instance_of.hpp b/contrib/restricted/boost/boost/lambda/detail/is_instance_of.hpp
deleted file mode 100644
index 1dfbd43a53..0000000000
--- a/contrib/restricted/boost/boost/lambda/detail/is_instance_of.hpp
+++ /dev/null
@@ -1,104 +0,0 @@
-// Boost Lambda Library - is_instance_of.hpp ---------------------
-
-// Copyright (C) 2001 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//
-// Distributed under 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)
-//
-// For more information, see www.boost.org
-
-// ---------------------------------------------------------------
-
-#ifndef BOOST_LAMBDA_IS_INSTANCE_OF
-#define BOOST_LAMBDA_IS_INSTANCE_OF
-
-#include "boost/config.hpp" // for BOOST_STATIC_CONSTANT
-#include "boost/type_traits/conversion_traits.hpp" // for is_convertible
-#include "boost/preprocessor/enum_shifted_params.hpp"
-#include "boost/preprocessor/repeat_2nd.hpp"
-
-// is_instance_of --------------------------------
-// 
-// is_instance_of_n<A, B>::value is true, if type A is 
-// an instantiation of a template B, or A derives from an instantiation 
-// of template B
-//
-// n is the number of template arguments for B
-// 
-// Example:
-// is_instance_of_2<std::istream, basic_stream>::value == true
-
-// The original implementation was somewhat different, with different versions
-// for different compilers. However, there was still a problem
-// with gcc.3.0.2 and 3.0.3 compilers, which didn't think regard
-// is_instance_of_N<...>::value was a constant.
-// John Maddock suggested the way around this problem by building 
-// is_instance_of templates using boost::is_convertible.
-// Now we only have one version of is_instance_of templates, which delagate
-// all the nasty compiler tricks to is_convertible. 
-
-#define BOOST_LAMBDA_CLASS(z, N,A) BOOST_PP_COMMA_IF(N) class
-#define BOOST_LAMBDA_CLASS_ARG(z, N,A) BOOST_PP_COMMA_IF(N) class A##N 
-#define BOOST_LAMBDA_ARG(z, N,A) BOOST_PP_COMMA_IF(N) A##N 
-
-#define BOOST_LAMBDA_CLASS_LIST(n, NAME) BOOST_PP_REPEAT(n, BOOST_LAMBDA_CLASS, NAME)
-
-#define BOOST_LAMBDA_CLASS_ARG_LIST(n, NAME) BOOST_PP_REPEAT(n, BOOST_LAMBDA_CLASS_ARG, NAME)
-
-#define BOOST_LAMBDA_ARG_LIST(n, NAME) BOOST_PP_REPEAT(n, BOOST_LAMBDA_ARG, NAME)
-
-namespace boost {
-namespace lambda {
-
-#define BOOST_LAMBDA_IS_INSTANCE_OF_TEMPLATE(INDEX)                         \
-                                                                            \
-namespace detail {                                                          \
-                                                                            \
-template <template<BOOST_LAMBDA_CLASS_LIST(INDEX,T)> class F>               \
-struct BOOST_PP_CAT(conversion_tester_,INDEX) {                             \
-  template<BOOST_LAMBDA_CLASS_ARG_LIST(INDEX,A)>                            \
-  BOOST_PP_CAT(conversion_tester_,INDEX)                                    \
-    (const F<BOOST_LAMBDA_ARG_LIST(INDEX,A)>&);                             \
-};                                                                          \
-                                                                            \
-} /* end detail */                                                          \
-                                                                            \
-template <class From, template <BOOST_LAMBDA_CLASS_LIST(INDEX,T)> class To> \
-struct BOOST_PP_CAT(is_instance_of_,INDEX)                                  \
-{                                                                           \
- private:                                                                   \
-   typedef ::boost::is_convertible<                                         \
-     From,                                                                  \
-     BOOST_PP_CAT(detail::conversion_tester_,INDEX)<To>                     \
-   > helper_type;                                                           \
-                                                                            \
-public:                                                                     \
-  BOOST_STATIC_CONSTANT(bool, value = helper_type::value);                  \
-};
-
-
-#define BOOST_LAMBDA_HELPER(z, N, A) BOOST_LAMBDA_IS_INSTANCE_OF_TEMPLATE( BOOST_PP_INC(N) )
-
-// Generate the traits for 1-4 argument templates
-
-BOOST_PP_REPEAT_2ND(4,BOOST_LAMBDA_HELPER,FOO)
-
-#undef BOOST_LAMBDA_HELPER
-#undef BOOST_LAMBDA_IS_INSTANCE_OF_TEMPLATE
-#undef BOOST_LAMBDA_CLASS
-#undef BOOST_LAMBDA_ARG
-#undef BOOST_LAMBDA_CLASS_ARG
-#undef BOOST_LAMBDA_CLASS_LIST
-#undef BOOST_LAMBDA_ARG_LIST
-#undef BOOST_LAMBDA_CLASS_ARG_LIST
-
-} // lambda
-} // boost
-
-#endif
-
-
-
-
-
diff --git a/contrib/restricted/boost/boost/lambda/detail/lambda_config.hpp b/contrib/restricted/boost/boost/lambda/detail/lambda_config.hpp
deleted file mode 100644
index f47100b969..0000000000
--- a/contrib/restricted/boost/boost/lambda/detail/lambda_config.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-// Boost Lambda Library - lambda_config.hpp ------------------------------
-
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//
-// Distributed under 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)
-//
-// For more information, see www.boost.org
-
-// ---------------------------------------------------------------
-
-#ifndef BOOST_LAMBDA_LAMBDA_CONFIG_HPP
-#define BOOST_LAMBDA_LAMBDA_CONFIG_HPP
-
-// add to boost/config.hpp
-// for now
-
-
-# if defined __GNUC__
-#   if (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) 
-#     define BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
-#     define BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING
-#   endif
-# endif  // __GNUC__
- 
-
-#if defined __KCC
-
-#define BOOST_NO_FDECL_TEMPLATES_AS_TEMPLATE_TEMPLATE_PARAMS
-
-#endif  // __KCC
-
-#endif
-
-
-
-
-
-
-
diff --git a/contrib/restricted/boost/boost/lambda/detail/lambda_functor_base.hpp b/contrib/restricted/boost/boost/lambda/detail/lambda_functor_base.hpp
deleted file mode 100644
index b084acd21a..0000000000
--- a/contrib/restricted/boost/boost/lambda/detail/lambda_functor_base.hpp
+++ /dev/null
@@ -1,615 +0,0 @@
-// Boost Lambda Library  lambda_functor_base.hpp -----------------------------
-//
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//
-// Distributed under 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)
-//
-// For more information, see www.boost.org
-
-// ------------------------------------------------------------
-
-#ifndef BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_HPP
-#define BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_HPP
-
-#include "boost/type_traits/add_reference.hpp"
-#include "boost/type_traits/add_const.hpp"
-#include "boost/type_traits/remove_const.hpp"
-#include "boost/lambda/detail/lambda_fwd.hpp"
-#include "boost/lambda/detail/lambda_traits.hpp"
-
-namespace boost { 
-namespace lambda {
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(push)
-#pragma warning(disable:4512) //assignment operator could not be generated
-#endif
-
-  // for return type deductions we wrap bound argument to this class,
-  // which fulfils the base class contract for lambda_functors
-template <class T>
-class identity {
-
-  T elem;
-public:
-  
-  typedef T element_t;
-
-  // take all parameters as const references. Note that non-const references
-  // stay as they are.
-  typedef typename boost::add_reference<
-    typename boost::add_const<T>::type
-  >::type par_t;
-
-  explicit identity(par_t t) : elem(t) {}
-
-  template <typename SigArgs> 
-  struct sig { typedef typename boost::remove_const<element_t>::type type; };
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const { CALL_USE_ARGS; return elem; }
-};
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(pop)
-#endif
-
-template <class T> 
-inline lambda_functor<identity<T&> > var(T& t) { return identity<T&>(t); }
-
-  // for lambda functors, var is an identity operator. It was forbidden
-  // at some point, but we might want to var something that can be a 
-  // non-lambda functor or a lambda functor.
-template <class T>
-lambda_functor<T> var(const lambda_functor<T>& t) { return t; }
-
-template <class T> struct var_type {
-  typedef lambda_functor<identity<T&> > type;
-};
-
-
-template <class T> 
-inline 
-lambda_functor<identity<typename bound_argument_conversion<const T>::type> >
-constant(const T& t) { 
-  return identity<typename bound_argument_conversion<const T>::type>(t); 
-}
-template <class T>
-lambda_functor<T> constant(const lambda_functor<T>& t) { return t; }
-
-template <class T> struct constant_type {
-  typedef 
-   lambda_functor<
-     identity<typename bound_argument_conversion<const T>::type> 
-   > type;
-};
-
-
-
-template <class T> 
-inline lambda_functor<identity<const T&> > constant_ref(const T& t) { 
-  return identity<const T&>(t); 
-}
-template <class T>
-lambda_functor<T> constant_ref(const lambda_functor<T>& t) { return t; }
-
-template <class T> struct constant_ref_type {
-  typedef 
-   lambda_functor<identity<const T&> > type;
-};
-
-
-
-  // as_lambda_functor turns any types to lambda functors 
-  // non-lambda_functors will be bound argument types
-template <class T>
-struct as_lambda_functor { 
-  typedef typename 
-    detail::remove_reference_and_cv<T>::type plain_T;
-  typedef typename 
-    detail::IF<is_lambda_functor<plain_T>::value, 
-      plain_T,
-      lambda_functor<
-        identity<typename bound_argument_conversion<T>::type> 
-      >
-    >::RET type; 
-};
-
-// turns arbitrary objects into lambda functors
-template <class T> 
-inline 
-lambda_functor<identity<typename bound_argument_conversion<const T>::type> > 
-to_lambda_functor(const T& t) { 
-  return identity<typename bound_argument_conversion<const T>::type>(t);
-}
-
-template <class T> 
-inline lambda_functor<T> 
-to_lambda_functor(const lambda_functor<T>& t) { 
-  return t;
-}
-
-namespace detail {   
-
-
-
-// In a call constify_rvals<T>::go(x)
-// x should be of type T. If T is a non-reference type, do
-// returns x as const reference. 
-// Otherwise the type doesn't change.
-// The purpose of this class is to avoid 
-// 'cannot bind temporaries to non-const references' errors.
-template <class T> struct constify_rvals {
-  template<class U>
-  static inline const U& go(const U& u) { return u; }
-};
-
-template <class T> struct constify_rvals<T&> {
-  template<class U>
-  static inline U& go(U& u) { return u; }
-};
-
-  // check whether one of the elements of a tuple (cons list) is of type
-  // null_type. Needed, because the compiler goes ahead and instantiates
-  // sig template for nullary case even if the nullary operator() is not
-  // called
-template <class T> struct is_null_type 
-{ BOOST_STATIC_CONSTANT(bool, value = false); };
-
-template <> struct is_null_type<null_type> 
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-
-template<class Tuple> struct has_null_type {
-  BOOST_STATIC_CONSTANT(bool, value = (is_null_type<typename Tuple::head_type>::value || has_null_type<typename Tuple::tail_type>::value));
-};
-template<> struct has_null_type<null_type> {
-  BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-
-// helpers -------------------
-
-
-template<class Args, class SigArgs>
-class deduce_argument_types_ {
-  typedef typename as_lambda_functor<typename Args::head_type>::type lf_t;
-  typedef typename lf_t::inherited::template sig<SigArgs>::type el_t;  
-public:
-  typedef
-    boost::tuples::cons<
-      el_t, 
-      typename deduce_argument_types_<typename Args::tail_type, SigArgs>::type
-    > type;
-};
-
-template<class SigArgs>
-class deduce_argument_types_<null_type, SigArgs> {
-public:
-  typedef null_type type; 
-};
-
-
-//  // note that tuples cannot have plain function types as elements.
-//  // Hence, all other types will be non-const, except references to 
-//  // functions.
-//  template <class T> struct remove_reference_except_from_functions {
-//    typedef typename boost::remove_reference<T>::type t;
-//    typedef typename detail::IF<boost::is_function<t>::value, T, t>::RET type;
-//  };
-
-template<class Args, class SigArgs>
-class deduce_non_ref_argument_types_ {
-  typedef typename as_lambda_functor<typename Args::head_type>::type lf_t;
-  typedef typename lf_t::inherited::template sig<SigArgs>::type el_t;  
-public:
-  typedef
-    boost::tuples::cons<
-  //      typename detail::remove_reference_except_from_functions<el_t>::type, 
-      typename boost::remove_reference<el_t>::type, 
-      typename deduce_non_ref_argument_types_<typename Args::tail_type, SigArgs>::type
-    > type;
-};
-
-template<class SigArgs>
-class deduce_non_ref_argument_types_<null_type, SigArgs> {
-public:
-  typedef null_type type; 
-};
-
-  // -------------
-
-// take stored Args and Open Args, and return a const list with 
-// deduced elements (real return types)
-template<class Args, class SigArgs>
-class deduce_argument_types {
-  typedef typename deduce_argument_types_<Args, SigArgs>::type t1;
-public:
-  typedef typename detail::IF<
-    has_null_type<t1>::value, null_type, t1
-  >::RET type; 
-};
-
-// take stored Args and Open Args, and return a const list with 
-// deduced elements (references are stripped from the element types)
-
-template<class Args, class SigArgs>
-class deduce_non_ref_argument_types {
-  typedef typename deduce_non_ref_argument_types_<Args, SigArgs>::type t1;
-public:
-  typedef typename detail::IF<
-    has_null_type<t1>::value, null_type, t1
-  >::RET type; 
-};
-
-template <int N, class Args, class SigArgs>
-struct nth_return_type_sig {
-  typedef typename 
-          as_lambda_functor<
-            typename boost::tuples::element<N, Args>::type 
-  //            typename tuple_element_as_reference<N, Args>::type 
-        >::type lf_type;
-
-  typedef typename lf_type::inherited::template sig<SigArgs>::type type;  
-};
-
-template<int N, class Tuple> struct element_or_null {
-  typedef typename boost::tuples::element<N, Tuple>::type type;
-};
-
-template<int N> struct element_or_null<N, null_type> {
-  typedef null_type type;
-};
-
-
-   
-   
-} // end detail
-   
- // -- lambda_functor base ---------------------
-
-// the explicit_return_type_action case -----------------------------------
-template<class RET, class Args>
-class lambda_functor_base<explicit_return_type_action<RET>, Args> 
-{
-public:
-  Args args;
-
-  typedef RET result_type;
-
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template <class SigArgs> struct sig { typedef RET type; };
-
-  template<class RET_, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const 
-  {
-    return detail::constify_rvals<RET>::go(
-     detail::r_select<RET>::go(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS));
-  }
-};
-
-// the protect_action case -----------------------------------
-template<class Args>
-class lambda_functor_base<protect_action, Args>
-{
-public:
-  Args args;
-public:
-
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const 
-  {
-     CALL_USE_ARGS;
-     return boost::tuples::get<0>(args);
-  }
-
-  template<class SigArgs> struct sig { 
-    //    typedef typename detail::tuple_element_as_reference<0, SigArgs>::type type;
-    typedef typename boost::tuples::element<0, Args>::type type;
-  };
-};
-
-// Do nothing --------------------------------------------------------
-class do_nothing_action {};
-
-template<class Args>
-class lambda_functor_base<do_nothing_action, Args> {
-  //  Args args;
-public:
-  //  explicit lambda_functor_base(const Args& a) {}
-  lambda_functor_base() {}
-
-
-  template<class RET, CALL_TEMPLATE_ARGS> RET call(CALL_FORMAL_ARGS) const {
-    return CALL_USE_ARGS;
-  }
-
-  template<class SigArgs> struct sig { typedef void type; };
-};  
-
-
-//  These specializations provide a shorter notation to define actions.
-//  These lambda_functor_base instances take care of the recursive evaluation
-//  of the arguments and pass the evaluated arguments to the apply function
-//  of an action class. To make action X work with these classes, one must
-//  instantiate the lambda_functor_base as:
-//  lambda_functor_base<action<ARITY, X>, Args>
-//  Where ARITY is the arity of the apply function in X
-
-//  The return type is queried as:
-//  return_type_N<X, EvaluatedArgumentTypes>::type
-//  for which there must be a specialization.
-
-//  Function actions, casts, throws,... all go via these classes.
-
-
-template<class Act, class Args>  
-class lambda_functor_base<action<0, Act>, Args>           
-{  
-public:  
-//  Args args; not needed
-  explicit lambda_functor_base(const Args& /*a*/) {}  
-  
-  template<class SigArgs> struct sig {  
-    typedef typename return_type_N<Act, null_type>::type type;
-  };
-  
-  template<class RET, CALL_TEMPLATE_ARGS>  
-  RET call(CALL_FORMAL_ARGS) const {  
-    CALL_USE_ARGS;
-    return Act::template apply<RET>();
-  }
-};
-
-
-#if defined BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART  
-#error "Multiple defines of BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART"  
-#endif  
-  
-  
-#define BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(ARITY)             \
-template<class Act, class Args>                                        \
-class lambda_functor_base<action<ARITY, Act>, Args>                    \
-{                                                                      \
-public:                                                                \
-  Args args;                                                           \
-                                                                       \
-  explicit lambda_functor_base(const Args& a) : args(a) {}             \
-                                                                       \
-  template<class SigArgs> struct sig {                                 \
-    typedef typename                                                   \
-    detail::deduce_argument_types<Args, SigArgs>::type rets_t;         \
-  public:                                                              \
-    typedef typename                                                   \
-      return_type_N_prot<Act, rets_t>::type type;                      \
-  };                                                                   \
-                                                                       \
-                                                                       \
-  template<class RET, CALL_TEMPLATE_ARGS>                              \
-  RET call(CALL_FORMAL_ARGS) const {                                   \
-    using boost::tuples::get;                                          \
-    using detail::constify_rvals;                                      \
-    using detail::r_select;                                            \
-    using detail::element_or_null;                                     \
-    using detail::deduce_argument_types;                                
-
-BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(1)
-
-  typedef typename
-    deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t;
-  typedef typename element_or_null<0, rets_t>::type rt0;
-
-  return Act::template apply<RET>(
-    constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS))
-    );
-  }
-};
-
-
-BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(2)
-  
-  typedef typename 
-    deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t;
-  typedef typename element_or_null<0, rets_t>::type rt0;
-  typedef typename element_or_null<1, rets_t>::type rt1;
-
-  return Act::template apply<RET>(
-    constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS))
-    );
-  }
-};
-
-BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(3)
-
-  typedef typename 
-    deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t;
-
-  typedef typename element_or_null<0, rets_t>::type rt0;
-  typedef typename element_or_null<1, rets_t>::type rt1;
-  typedef typename element_or_null<2, rets_t>::type rt2;
-
-  return Act::template apply<RET>(
-    constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS))
-    );
-  }
-};
-
-BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(4)
-  typedef typename 
-    deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t;
-  typedef typename element_or_null<0, rets_t>::type rt0;
-  typedef typename element_or_null<1, rets_t>::type rt1;
-  typedef typename element_or_null<2, rets_t>::type rt2;
-  typedef typename element_or_null<3, rets_t>::type rt3;
-
-  return Act::template apply<RET>(
-    constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS))
-    );
-  }
-};
-
-BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(5)
-  typedef typename 
-    deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t;
-  typedef typename element_or_null<0, rets_t>::type rt0;
-  typedef typename element_or_null<1, rets_t>::type rt1;
-  typedef typename element_or_null<2, rets_t>::type rt2;
-  typedef typename element_or_null<3, rets_t>::type rt3;
-  typedef typename element_or_null<4, rets_t>::type rt4;
-
-  return Act::template apply<RET>(
-    constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt4>::go(r_select<rt4>::go(get<4>(args), CALL_ACTUAL_ARGS))
-    );
-  }
-};
-
-BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(6)
-
-  typedef typename 
-    deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t;
-  typedef typename element_or_null<0, rets_t>::type rt0;
-  typedef typename element_or_null<1, rets_t>::type rt1;
-  typedef typename element_or_null<2, rets_t>::type rt2;
-  typedef typename element_or_null<3, rets_t>::type rt3;
-  typedef typename element_or_null<4, rets_t>::type rt4;
-  typedef typename element_or_null<5, rets_t>::type rt5;
-
-
-    return Act::template apply<RET>(
-    constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt4>::go(r_select<rt4>::go(get<4>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt5>::go(r_select<rt5>::go(get<5>(args), CALL_ACTUAL_ARGS)) 
-    );
-  }
-};
-
-BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(7)
-  typedef typename 
-    deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t;
-  typedef typename element_or_null<0, rets_t>::type rt0;
-  typedef typename element_or_null<1, rets_t>::type rt1;
-  typedef typename element_or_null<2, rets_t>::type rt2;
-  typedef typename element_or_null<3, rets_t>::type rt3;
-  typedef typename element_or_null<4, rets_t>::type rt4;
-  typedef typename element_or_null<5, rets_t>::type rt5;
-  typedef typename element_or_null<6, rets_t>::type rt6;
-
-
-  return Act::template apply<RET>(
-    constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt4>::go(r_select<rt4>::go(get<4>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt5>::go(r_select<rt5>::go(get<5>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt6>::go(r_select<rt6>::go(get<6>(args), CALL_ACTUAL_ARGS))
-    );
-  }
-};
-
-BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(8)
-  typedef typename 
-    deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t;
-  typedef typename element_or_null<0, rets_t>::type rt0;
-  typedef typename element_or_null<1, rets_t>::type rt1;
-  typedef typename element_or_null<2, rets_t>::type rt2;
-  typedef typename element_or_null<3, rets_t>::type rt3;
-  typedef typename element_or_null<4, rets_t>::type rt4;
-  typedef typename element_or_null<5, rets_t>::type rt5;
-  typedef typename element_or_null<6, rets_t>::type rt6;
-  typedef typename element_or_null<7, rets_t>::type rt7;
-
-  return Act::template apply<RET>(
-    constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt4>::go(r_select<rt4>::go(get<4>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt5>::go(r_select<rt5>::go(get<5>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt6>::go(r_select<rt6>::go(get<6>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt7>::go(r_select<rt7>::go(get<7>(args), CALL_ACTUAL_ARGS))
-    );
-  }
-};
-
-BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(9)
-  typedef typename 
-    deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t;
-  typedef typename element_or_null<0, rets_t>::type rt0;
-  typedef typename element_or_null<1, rets_t>::type rt1;
-  typedef typename element_or_null<2, rets_t>::type rt2;
-  typedef typename element_or_null<3, rets_t>::type rt3;
-  typedef typename element_or_null<4, rets_t>::type rt4;
-  typedef typename element_or_null<5, rets_t>::type rt5;
-  typedef typename element_or_null<6, rets_t>::type rt6;
-  typedef typename element_or_null<7, rets_t>::type rt7;
-  typedef typename element_or_null<8, rets_t>::type rt8;
-
-  return Act::template apply<RET>(
-    constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt4>::go(r_select<rt4>::go(get<4>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt5>::go(r_select<rt5>::go(get<5>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt6>::go(r_select<rt6>::go(get<6>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt7>::go(r_select<rt7>::go(get<7>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt8>::go(r_select<rt8>::go(get<8>(args), CALL_ACTUAL_ARGS))
-    );
-  }
-};
-
-BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(10) 
-  typedef typename 
-    deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t;
-  typedef typename element_or_null<0, rets_t>::type rt0;
-  typedef typename element_or_null<1, rets_t>::type rt1;
-  typedef typename element_or_null<2, rets_t>::type rt2;
-  typedef typename element_or_null<3, rets_t>::type rt3;
-  typedef typename element_or_null<4, rets_t>::type rt4;
-  typedef typename element_or_null<5, rets_t>::type rt5;
-  typedef typename element_or_null<6, rets_t>::type rt6;
-  typedef typename element_or_null<7, rets_t>::type rt7;
-  typedef typename element_or_null<8, rets_t>::type rt8;
-  typedef typename element_or_null<9, rets_t>::type rt9;
-
-  return Act::template apply<RET>(
-    constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt4>::go(r_select<rt4>::go(get<4>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt5>::go(r_select<rt5>::go(get<5>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt6>::go(r_select<rt6>::go(get<6>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt7>::go(r_select<rt7>::go(get<7>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt8>::go(r_select<rt8>::go(get<8>(args), CALL_ACTUAL_ARGS)),
-    constify_rvals<rt9>::go(r_select<rt9>::go(get<9>(args), CALL_ACTUAL_ARGS)) 
-    );
-  }
-};
-
-#undef BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART
-
-
-} // namespace lambda
-} // namespace boost
-
-#endif
diff --git a/contrib/restricted/boost/boost/lambda/detail/lambda_functors.hpp b/contrib/restricted/boost/boost/lambda/detail/lambda_functors.hpp
deleted file mode 100644
index febb6fc828..0000000000
--- a/contrib/restricted/boost/boost/lambda/detail/lambda_functors.hpp
+++ /dev/null
@@ -1,357 +0,0 @@
-// Boost Lambda Library -  lambda_functors.hpp -------------------------------
-
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//
-// Distributed under 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)
-//
-// For more information, see http://www.boost.org
-
-// ------------------------------------------------
-
-#ifndef BOOST_LAMBDA_LAMBDA_FUNCTORS_HPP
-#define BOOST_LAMBDA_LAMBDA_FUNCTORS_HPP
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/utility/result_of.hpp>
-
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
-
-#include <boost/mpl/or.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/is_array.hpp>
-
-#define BOOST_LAMBDA_DISABLE_IF_ARRAY1(A1, R1)\
-  typename lazy_disable_if<is_array<A1>, typename R1 >::type
-#define BOOST_LAMBDA_DISABLE_IF_ARRAY2(A1, A2, R1, R2) \
-  typename lazy_disable_if<mpl::or_<is_array<A1>, is_array<A2> >, typename R1, R2 >::type
-#define BOOST_LAMBDA_DISABLE_IF_ARRAY3(A1, A2, A3, R1, R2, R3) \
-  typename lazy_disable_if<mpl::or_<is_array<A1>, is_array<A2>, is_array<A3> >, typename R1, R2, R3 >::type
-
-#else
-
-#define BOOST_LAMBDA_DISABLE_IF_ARRAY1(A1, R1) typename R1::type
-#define BOOST_LAMBDA_DISABLE_IF_ARRAY2(A1, A2, R1, R2) typename R1, R2::type
-#define BOOST_LAMBDA_DISABLE_IF_ARRAY3(A1, A2, A3, R1, R2, R3) typename R1, R2, R3::type
-
-#endif
-
-namespace boost { 
-namespace lambda {
-
-// -- lambda_functor --------------------------------------------
-// --------------------------------------------------------------
-
-//inline const null_type const_null_type() { return null_type(); }
-
-namespace detail {
-namespace {
-
-  static const null_type constant_null_type = null_type();
-
-} // unnamed
-} // detail
-
-class unused {};
-
-#define cnull_type() detail::constant_null_type
-
-// -- free variables types -------------------------------------------------- 
- 
-  // helper to work around the case where the nullary return type deduction 
-  // is always performed, even though the functor is not nullary  
-namespace detail {
-  template<int N, class Tuple> struct get_element_or_null_type {
-    typedef typename 
-      detail::tuple_element_as_reference<N, Tuple>::type type;
-  };
-  template<int N> struct get_element_or_null_type<N, null_type> {
-    typedef null_type type;
-  };
-}
-
-template <int I> struct placeholder;
-
-template<> struct placeholder<FIRST> {
-
-  template<class SigArgs> struct sig {
-    typedef typename detail::get_element_or_null_type<0, SigArgs>::type type;
-  };
-
-  template<class RET, CALL_TEMPLATE_ARGS> 
-  RET call(CALL_FORMAL_ARGS) const { 
-    BOOST_STATIC_ASSERT(boost::is_reference<RET>::value); 
-    CALL_USE_ARGS; // does nothing, prevents warnings for unused args
-    return a; 
-  }
-};
-
-template<> struct placeholder<SECOND> {
-
-  template<class SigArgs> struct sig {
-    typedef typename detail::get_element_or_null_type<1, SigArgs>::type type;
-  };
-
-  template<class RET, CALL_TEMPLATE_ARGS> 
-  RET call(CALL_FORMAL_ARGS) const { CALL_USE_ARGS; return b; }
-};
-
-template<> struct placeholder<THIRD> {
-
-  template<class SigArgs> struct sig {
-    typedef typename detail::get_element_or_null_type<2, SigArgs>::type type;
-  };
-
-  template<class RET, CALL_TEMPLATE_ARGS> 
-  RET call(CALL_FORMAL_ARGS) const { CALL_USE_ARGS; return c; }
-};
-
-template<> struct placeholder<EXCEPTION> {
-
-  template<class SigArgs> struct sig {
-    typedef typename detail::get_element_or_null_type<3, SigArgs>::type type;
-  };
-
-  template<class RET, CALL_TEMPLATE_ARGS> 
-  RET call(CALL_FORMAL_ARGS) const { CALL_USE_ARGS; return env; }
-};
-   
-typedef const lambda_functor<placeholder<FIRST> >  placeholder1_type;
-typedef const lambda_functor<placeholder<SECOND> > placeholder2_type;
-typedef const lambda_functor<placeholder<THIRD> >  placeholder3_type;
-   
-
-///////////////////////////////////////////////////////////////////////////////
-
-
-// free variables are lambda_functors. This is to allow uniform handling with 
-// other lambda_functors.
-// -------------------------------------------------------------------
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(push)
-#pragma warning(disable:4512) //assignment operator could not be generated
-#endif
-
-// -- lambda_functor NONE ------------------------------------------------
-template <class T>
-class lambda_functor : public T 
-{
-
-BOOST_STATIC_CONSTANT(int, arity_bits = get_arity<T>::value);
- 
-public:
-  typedef T inherited;
-
-  lambda_functor() {}
-  lambda_functor(const lambda_functor& l) : inherited(l) {}
-
-  lambda_functor(const T& t) : inherited(t) {}
-
-  template <class SigArgs> struct sig {
-    typedef typename inherited::template 
-      sig<typename SigArgs::tail_type>::type type;
-  };
-
-  // Note that this return type deduction template is instantiated, even 
-  // if the nullary 
-  // operator() is not called at all. One must make sure that it does not fail.
-  typedef typename 
-    inherited::template sig<null_type>::type
-      nullary_return_type;
-
-  // Support for boost::result_of.
-  template <class Sig> struct result;
-  template <class F>
-  struct result<F()> {
-    typedef nullary_return_type type;
-  };
-  template <class F, class A>
-  struct result<F(A)> {
-    typedef typename sig<tuple<F, A> >::type type;
-  };
-  template <class F, class A, class B>
-  struct result<F(A, B)> {
-    typedef typename sig<tuple<F, A, B> >::type type;
-  };
-  template <class F, class A, class B, class C>
-  struct result<F(A, B, C)> {
-    typedef typename sig<tuple<F, A, B, C> >::type type;
-  };
-
-  nullary_return_type operator()() const { 
-    return inherited::template 
-      call<nullary_return_type>
-        (cnull_type(), cnull_type(), cnull_type(), cnull_type()); 
-  }
-
-  template<class A>
-  typename inherited::template sig<tuple<A&> >::type
-  operator()(A& a) const { 
-    return inherited::template call<
-      typename inherited::template sig<tuple<A&> >::type
-    >(a, cnull_type(), cnull_type(), cnull_type());
-  }
-
-  template<class A>
-  BOOST_LAMBDA_DISABLE_IF_ARRAY1(A, inherited::template sig<tuple<A const&> >)
-  operator()(A const& a) const { 
-    return inherited::template call<
-      typename inherited::template sig<tuple<A const&> >::type
-    >(a, cnull_type(), cnull_type(), cnull_type());
-  }
-
-  template<class A, class B>
-  typename inherited::template sig<tuple<A&, B&> >::type
-  operator()(A& a, B& b) const { 
-    return inherited::template call<
-      typename inherited::template sig<tuple<A&, B&> >::type
-    >(a, b, cnull_type(), cnull_type()); 
-  }
-
-  template<class A, class B>
-  BOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A const&, B&> >)
-  operator()(A const& a, B& b) const { 
-    return inherited::template call<
-      typename inherited::template sig<tuple<A const&, B&> >::type
-    >(a, b, cnull_type(), cnull_type()); 
-  }
-
-  template<class A, class B>
-  BOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A&, B const&> >)
-  operator()(A& a, B const& b) const { 
-    return inherited::template call<
-      typename inherited::template sig<tuple<A&, B const&> >::type
-    >(a, b, cnull_type(), cnull_type()); 
-  }
-
-  template<class A, class B>
-  BOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A const&, B const&> >)
-  operator()(A const& a, B const& b) const { 
-    return inherited::template call<
-      typename inherited::template sig<tuple<A const&, B const&> >::type
-    >(a, b, cnull_type(), cnull_type()); 
-  }
-
-  template<class A, class B, class C>
-  typename inherited::template sig<tuple<A&, B&, C&> >::type
-  operator()(A& a, B& b, C& c) const
-  { 
-    return inherited::template call<
-      typename inherited::template sig<tuple<A&, B&, C&> >::type
-    >(a, b, c, cnull_type()); 
-  }
-
-  template<class A, class B, class C>
-  BOOST_LAMBDA_DISABLE_IF_ARRAY3(A, B, C, inherited::template sig<tuple<A const&, B const&, C const&> >)
-  operator()(A const& a, B const& b, C const& c) const
-  { 
-    return inherited::template call<
-      typename inherited::template sig<tuple<A const&, B const&, C const&> >::type
-    >(a, b, c, cnull_type()); 
-  }
-
-  // for internal calls with env
-  template<CALL_TEMPLATE_ARGS>
-  typename inherited::template sig<tuple<CALL_REFERENCE_TYPES> >::type
-  internal_call(CALL_FORMAL_ARGS) const { 
-     return inherited::template 
-       call<typename inherited::template 
-         sig<tuple<CALL_REFERENCE_TYPES> >::type>(CALL_ACTUAL_ARGS); 
-  }
-
-  template<class A>
-  const lambda_functor<lambda_functor_base<
-                  other_action<assignment_action>,
-                  boost::tuple<lambda_functor,
-                  typename const_copy_argument <const A>::type> > >
-  operator=(const A& a) const {
-    return lambda_functor_base<
-                  other_action<assignment_action>,
-                  boost::tuple<lambda_functor,
-                  typename const_copy_argument <const A>::type> >
-     (  boost::tuple<lambda_functor,
-             typename const_copy_argument <const A>::type>(*this, a) );
-  }
-
-  template<class A> 
-  const lambda_functor<lambda_functor_base< 
-                  other_action<subscript_action>, 
-                  boost::tuple<lambda_functor, 
-                        typename const_copy_argument <const A>::type> > > 
-  operator[](const A& a) const { 
-    return lambda_functor_base< 
-                  other_action<subscript_action>, 
-                  boost::tuple<lambda_functor, 
-                        typename const_copy_argument <const A>::type> >
-     ( boost::tuple<lambda_functor, 
-             typename const_copy_argument <const A>::type>(*this, a ) ); 
-  } 
-};
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(pop)
-#endif
-
-} // namespace lambda
-} // namespace boost
-
-namespace boost {
-
-#if !defined(BOOST_RESULT_OF_USE_DECLTYPE) || defined(BOOST_NO_CXX11_DECLTYPE)
-
-template<class T>
-struct result_of<boost::lambda::lambda_functor<T>()>
-{
-    typedef typename boost::lambda::lambda_functor<T>::nullary_return_type type;
-};
-
-template<class T>
-struct result_of<const boost::lambda::lambda_functor<T>()>
-{
-    typedef typename boost::lambda::lambda_functor<T>::nullary_return_type type;
-};
-
-#endif
-
-template<class T>
-struct tr1_result_of<boost::lambda::lambda_functor<T>()>
-{
-    typedef typename boost::lambda::lambda_functor<T>::nullary_return_type type;
-};
-
-template<class T>
-struct tr1_result_of<const boost::lambda::lambda_functor<T>()>
-{
-    typedef typename boost::lambda::lambda_functor<T>::nullary_return_type type;
-};
-
-}
-
-// is_placeholder
-
-#include <boost/is_placeholder.hpp>
-
-namespace boost
-{
-
-template<> struct is_placeholder< lambda::lambda_functor< lambda::placeholder<lambda::FIRST> > >
-{
-    enum _vt { value = 1 };
-};
-
-template<> struct is_placeholder< lambda::lambda_functor< lambda::placeholder<lambda::SECOND> > >
-{
-    enum _vt { value = 2 };
-};
-
-template<> struct is_placeholder< lambda::lambda_functor< lambda::placeholder<lambda::THIRD> > >
-{
-    enum _vt { value = 3 };
-};
-
-} // namespace boost
-
-#endif
diff --git a/contrib/restricted/boost/boost/lambda/detail/lambda_fwd.hpp b/contrib/restricted/boost/boost/lambda/detail/lambda_fwd.hpp
deleted file mode 100644
index a27bfaded1..0000000000
--- a/contrib/restricted/boost/boost/lambda/detail/lambda_fwd.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-//  lambda_fwd.hpp - Boost Lambda Library -------------------------------
-
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//
-// Distributed under 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)
-//
-// For more information, see www.boost.org
-
-// -------------------------------------------------------
-
-#ifndef BOOST_LAMBDA_FWD_HPP
-#define BOOST_LAMBDA_FWD_HPP
-
-namespace boost { 
-namespace lambda { 
-
-namespace detail {
-
-template<class T> struct generate_error;
-
-}   
-// -- placeholders --------------------------------------------
-
-template <int I> struct placeholder;
-
-// function_adaptors
-template <class Func> 
-struct function_adaptor;
-
-template <int I, class Act> class action;
-
-template <class Base> 
-class lambda_functor;
-
-template <class Act, class Args> 
-class lambda_functor_base;
-
-} // namespace lambda
-} // namespace boost
-
-
-//  #define CALL_TEMPLATE_ARGS class A, class Env
-//  #define CALL_FORMAL_ARGS A& a, Env& env
-//  #define CALL_ACTUAL_ARGS a, env
-//  #define CALL_ACTUAL_ARGS_NO_ENV a
-//  #define CALL_REFERENCE_TYPES A&, Env&
-//  #define CALL_PLAIN_TYPES A, Env
-#define CALL_TEMPLATE_ARGS class A, class B, class C, class Env
-#define CALL_FORMAL_ARGS A& a, B& b, C& c, Env& env
-#define CALL_ACTUAL_ARGS a, b, c, env
-#define CALL_ACTUAL_ARGS_NO_ENV a, b, c
-#define CALL_REFERENCE_TYPES A&, B&, C&, Env&
-#define CALL_PLAIN_TYPES A, B, C, Env
-
-namespace boost {
-namespace lambda {
-namespace detail {
-
-template<class A1, class A2, class A3, class A4>
-void do_nothing(A1&, A2&, A3&, A4&) {}
-
-} // detail
-} // lambda
-} // boost
-
-// prevent the warnings from unused arguments
-#define CALL_USE_ARGS \
-::boost::lambda::detail::do_nothing(a, b, c, env)
-
-
-
-#endif
diff --git a/contrib/restricted/boost/boost/lambda/detail/lambda_traits.hpp b/contrib/restricted/boost/boost/lambda/detail/lambda_traits.hpp
deleted file mode 100644
index cae0f38e6d..0000000000
--- a/contrib/restricted/boost/boost/lambda/detail/lambda_traits.hpp
+++ /dev/null
@@ -1,583 +0,0 @@
-// - lambda_traits.hpp --- Boost Lambda Library ----------------------------
-//
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//
-// Distributed under 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)
-//
-// For more information, see www.boost.org
-// -------------------------------------------------------------------------
-
-#ifndef BOOST_LAMBDA_LAMBDA_TRAITS_HPP
-#define BOOST_LAMBDA_LAMBDA_TRAITS_HPP
-
-#include "boost/type_traits/transform_traits.hpp"
-#include "boost/type_traits/cv_traits.hpp"
-#include "boost/type_traits/function_traits.hpp"
-#include "boost/type_traits/object_traits.hpp"
-#include "boost/tuple/tuple.hpp"
-
-namespace boost {
-namespace lambda {
-
-// -- if construct ------------------------------------------------
-// Proposed by Krzysztof Czarnecki and Ulrich Eisenecker
-
-namespace detail {
-
-template <bool If, class Then, class Else> struct IF { typedef Then RET; };
-
-template <class Then, class Else> struct IF<false, Then, Else> {
-  typedef Else RET;
-};
-
-
-// An if construct that doesn't instantiate the non-matching template:
-
-// Called as: 
-//  IF_type<condition, A, B>::type 
-// The matching template must define the typeded 'type'
-// I.e. A::type if condition is true, B::type if condition is false
-// Idea from Vesa Karvonen (from C&E as well I guess)
-template<class T>
-struct IF_type_
-{
-  typedef typename T::type type;
-};
-
-
-template<bool C, class T, class E>
-struct IF_type
-{
-  typedef typename
-    IF_type_<typename IF<C, T, E>::RET >::type type;
-};
-
-// helper that can be used to give typedef T to some type
-template <class T> struct identity_mapping { typedef T type; };
-
-// An if construct for finding an integral constant 'value'
-// Does not instantiate the non-matching branch
-// Called as IF_value<condition, A, B>::value
-// If condition is true A::value must be defined, otherwise B::value
-
-template<class T>
-struct IF_value_
-{
-  BOOST_STATIC_CONSTANT(int, value = T::value);
-};
-
-
-template<bool C, class T, class E>
-struct IF_value
-{
-  BOOST_STATIC_CONSTANT(int, value = (IF_value_<typename IF<C, T, E>::RET>::value));
-};
-
-
-// --------------------------------------------------------------
-
-// removes reference from other than function types:
-template<class T> class remove_reference_if_valid
-{
-
-  typedef typename boost::remove_reference<T>::type plainT;
-public:
-  typedef typename IF<
-    boost::is_function<plainT>::value,
-    T,
-    plainT
-  >::RET type;
-
-};
-
-
-template<class T> struct remove_reference_and_cv {
-   typedef typename boost::remove_cv<
-     typename boost::remove_reference<T>::type
-   >::type type;
-};
-
-
-   
-// returns a reference to the element of tuple T
-template<int N, class T> struct tuple_element_as_reference {   
-  typedef typename
-     boost::tuples::access_traits<
-       typename boost::tuples::element<N, T>::type
-     >::non_const_type type;
-};
-
-// returns the cv and reverence stripped type of a tuple element
-template<int N, class T> struct tuple_element_stripped {   
-  typedef typename
-     remove_reference_and_cv<
-       typename boost::tuples::element<N, T>::type
-     >::type type;
-};
-
-// is_lambda_functor -------------------------------------------------   
-
-template <class T> struct is_lambda_functor_ {
-  BOOST_STATIC_CONSTANT(bool, value = false);
-};
-   
-template <class Arg> struct is_lambda_functor_<lambda_functor<Arg> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-   
-} // end detail
-
-   
-template <class T> struct is_lambda_functor {
-  BOOST_STATIC_CONSTANT(bool, 
-     value = 
-       detail::is_lambda_functor_<
-         typename detail::remove_reference_and_cv<T>::type
-       >::value);
-};
-   
-
-namespace detail {
-
-// -- parameter_traits_ ---------------------------------------------
-
-// An internal parameter type traits class that respects
-// the reference_wrapper class.
-
-// The conversions performed are:
-// references -> compile_time_error
-// T1 -> T2, 
-// reference_wrapper<T> -> T&
-// const array -> ref to const array
-// array -> ref to array
-// function -> ref to function
-
-// ------------------------------------------------------------------------
-
-template<class T1, class T2> 
-struct parameter_traits_ {
-  typedef T2 type;
-};
-
-// Do not instantiate with reference types
-template<class T, class Any> struct parameter_traits_<T&, Any> {
-  typedef typename 
-    generate_error<T&>::
-      parameter_traits_class_instantiated_with_reference_type type;
-};
-
-// Arrays can't be stored as plain types; convert them to references
-template<class T, int n, class Any> struct parameter_traits_<T[n], Any> {
-  typedef T (&type)[n];
-};
-   
-template<class T, int n, class Any> 
-struct parameter_traits_<const T[n], Any> {
-  typedef const T (&type)[n];
-};
-
-template<class T, int n, class Any> 
-struct parameter_traits_<volatile T[n], Any> {
-  typedef volatile  T (&type)[n];
-};
-template<class T, int n, class Any> 
-struct parameter_traits_<const volatile T[n], Any> {
-  typedef const volatile T (&type)[n];
-};
-
-
-template<class T, class Any> 
-struct parameter_traits_<boost::reference_wrapper<T>, Any >{
-  typedef T& type;
-};
-
-template<class T, class Any> 
-struct parameter_traits_<const boost::reference_wrapper<T>, Any >{
-  typedef T& type;
-};
-
-template<class T, class Any> 
-struct parameter_traits_<volatile boost::reference_wrapper<T>, Any >{
-  typedef T& type;
-};
-
-template<class T, class Any> 
-struct parameter_traits_<const volatile boost::reference_wrapper<T>, Any >{
-  typedef T& type;
-};
-
-template<class Any>
-struct parameter_traits_<void, Any> {
-  typedef void type;
-};
-
-template<class Arg, class Any>
-struct parameter_traits_<lambda_functor<Arg>, Any > {
-  typedef lambda_functor<Arg> type;
-};
-
-template<class Arg, class Any>
-struct parameter_traits_<const lambda_functor<Arg>, Any > {
-  typedef lambda_functor<Arg> type;
-};
-
-// Are the volatile versions needed?
-template<class Arg, class Any>
-struct parameter_traits_<volatile lambda_functor<Arg>, Any > {
-  typedef lambda_functor<Arg> type;
-};
-
-template<class Arg, class Any>
-struct parameter_traits_<const volatile lambda_functor<Arg>, Any > {
-  typedef lambda_functor<Arg> type;
-};
-
-} // end namespace detail
-
-
-// ------------------------------------------------------------------------
-// traits classes for lambda expressions (bind functions, operators ...)   
-
-// must be instantiated with non-reference types
-
-// The default is const plain type -------------------------
-// const T -> const T, 
-// T -> const T, 
-// references -> compile_time_error
-// reference_wrapper<T> -> T&
-// array -> const ref array
-template<class T>
-struct const_copy_argument {
-  typedef typename 
-    detail::parameter_traits_<
-      T,
-      typename detail::IF<boost::is_function<T>::value, T&, const T>::RET
-    >::type type;
-};
-
-// T may be a function type. Without the IF test, const would be added 
-// to a function type, which is illegal.
-
-// all arrays are converted to const.
-// This traits template is used for 'const T&' parameter passing 
-// and thus the knowledge of the potential 
-// non-constness of an actual argument is lost.   
-template<class T, int n>  struct const_copy_argument <T[n]> {
-  typedef const T (&type)[n];
-};
-template<class T, int n>  struct const_copy_argument <volatile T[n]> {
-     typedef const volatile T (&type)[n];
-};
-   
-template<class T>
-struct const_copy_argument<T&> {};
-// do not instantiate with references
-  //  typedef typename detail::generate_error<T&>::references_not_allowed type;
-
-
-template<>
-struct const_copy_argument<void> {
-  typedef void type;
-};
-
-template<>
-struct const_copy_argument<void const> {
-  typedef void type;
-};
-
-
-// Does the same as const_copy_argument, but passes references through as such
-template<class T>
-struct bound_argument_conversion {
-  typedef typename const_copy_argument<T>::type type; 
-};
-
-template<class T>
-struct bound_argument_conversion<T&> {
-  typedef T& type; 
-};
-   
-// The default is non-const reference -------------------------
-// const T -> const T&, 
-// T -> T&, 
-// references -> compile_time_error
-// reference_wrapper<T> -> T&
-template<class T>
-struct reference_argument {
-  typedef typename detail::parameter_traits_<T, T&>::type type; 
-};
-
-template<class T>
-struct reference_argument<T&> {
-  typedef typename detail::generate_error<T&>::references_not_allowed type; 
-};
-
-template<class Arg>
-struct reference_argument<lambda_functor<Arg> > {
-  typedef lambda_functor<Arg> type;
-};
-
-template<class Arg>
-struct reference_argument<const lambda_functor<Arg> > {
-  typedef lambda_functor<Arg> type;
-};
-
-// Are the volatile versions needed?
-template<class Arg>
-struct reference_argument<volatile lambda_functor<Arg> > {
-  typedef lambda_functor<Arg> type;
-};
-
-template<class Arg>
-struct reference_argument<const volatile lambda_functor<Arg> > {
-  typedef lambda_functor<Arg> type;
-};
-
-template<>
-struct reference_argument<void> {
-  typedef void type;
-};
-
-namespace detail {
-   
-// Array to pointer conversion
-template <class T>
-struct array_to_pointer { 
-  typedef T type;
-};
-
-template <class T, int N>
-struct array_to_pointer <const T[N]> { 
-  typedef const T* type;
-};
-template <class T, int N>
-struct array_to_pointer <T[N]> { 
-  typedef T* type;
-};
-
-template <class T, int N>
-struct array_to_pointer <const T (&) [N]> { 
-  typedef const T* type;
-};
-template <class T, int N>
-struct array_to_pointer <T (&) [N]> { 
-  typedef T* type;
-};
-
-
-// ---------------------------------------------------------------------------
-// The call_traits for bind
-// Respects the reference_wrapper class.
-
-// These templates are used outside of bind functions as well.
-// the bind_tuple_mapper provides a shorter notation for default
-// bound argument storing semantics, if all arguments are treated
-// uniformly.
-
-// from template<class T> foo(const T& t) : bind_traits<const T>::type
-// from template<class T> foo(T& t) : bind_traits<T>::type
-
-// Conversions:
-// T -> const T,
-// cv T -> cv T, 
-// T& -> T& 
-// reference_wrapper<T> -> T&
-// const reference_wrapper<T> -> T&
-// array -> const ref array
-
-// make bound arguments const, this is a deliberate design choice, the
-// purpose is to prevent side effects to bound arguments that are stored
-// as copies
-template<class T>
-struct bind_traits {
-  typedef const T type; 
-};
-
-template<class T>
-struct bind_traits<T&> {
-  typedef T& type; 
-};
-
-// null_types are an exception, we always want to store them as non const
-// so that other templates can assume that null_type is always without const
-template<>
-struct bind_traits<null_type> {
-  typedef null_type type;
-};
-
-// the bind_tuple_mapper, bind_type_generators may 
-// introduce const to null_type
-template<>
-struct bind_traits<const null_type> {
-  typedef null_type type;
-};
-
-// Arrays can't be stored as plain types; convert them to references.
-// All arrays are converted to const. This is because bind takes its
-// parameters as const T& and thus the knowledge of the potential 
-// non-constness of actual argument is lost.
-template<class T, int n>  struct bind_traits <T[n]> {
-  typedef const T (&type)[n];
-};
-
-template<class T, int n> 
-struct bind_traits<const T[n]> {
-  typedef const T (&type)[n];
-};
-
-template<class T, int n>  struct bind_traits<volatile T[n]> {
-  typedef const volatile T (&type)[n];
-};
-
-template<class T, int n> 
-struct bind_traits<const volatile T[n]> {
-  typedef const volatile T (&type)[n];
-};
-
-template<class R>
-struct bind_traits<R()> {
-    typedef R(&type)();
-};
-
-template<class R, class Arg1>
-struct bind_traits<R(Arg1)> {
-    typedef R(&type)(Arg1);
-};
-
-template<class R, class Arg1, class Arg2>
-struct bind_traits<R(Arg1, Arg2)> {
-    typedef R(&type)(Arg1, Arg2);
-};
-
-template<class R, class Arg1, class Arg2, class Arg3>
-struct bind_traits<R(Arg1, Arg2, Arg3)> {
-    typedef R(&type)(Arg1, Arg2, Arg3);
-};
-
-template<class R, class Arg1, class Arg2, class Arg3, class Arg4>
-struct bind_traits<R(Arg1, Arg2, Arg3, Arg4)> {
-    typedef R(&type)(Arg1, Arg2, Arg3, Arg4);
-};
-
-template<class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5>
-struct bind_traits<R(Arg1, Arg2, Arg3, Arg4, Arg5)> {
-    typedef R(&type)(Arg1, Arg2, Arg3, Arg4, Arg5);
-};
-
-template<class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6>
-struct bind_traits<R(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {
-    typedef R(&type)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6);
-};
-
-template<class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7>
-struct bind_traits<R(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {
-    typedef R(&type)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7);
-};
-
-template<class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8>
-struct bind_traits<R(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {
-    typedef R(&type)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8);
-};
-
-template<class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9>
-struct bind_traits<R(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)> {
-    typedef R(&type)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9);
-};
-
-template<class T> 
-struct bind_traits<reference_wrapper<T> >{
-  typedef T& type;
-};
-
-template<class T> 
-struct bind_traits<const reference_wrapper<T> >{
-  typedef T& type;
-};
-
-template<>
-struct bind_traits<void> {
-  typedef void type;
-};
-
-
-
-template <
-  class T0 = null_type, class T1 = null_type, class T2 = null_type, 
-  class T3 = null_type, class T4 = null_type, class T5 = null_type, 
-  class T6 = null_type, class T7 = null_type, class T8 = null_type, 
-  class T9 = null_type
->
-struct bind_tuple_mapper {
-  typedef
-    tuple<typename bind_traits<T0>::type, 
-          typename bind_traits<T1>::type, 
-          typename bind_traits<T2>::type, 
-          typename bind_traits<T3>::type, 
-          typename bind_traits<T4>::type, 
-          typename bind_traits<T5>::type, 
-          typename bind_traits<T6>::type, 
-          typename bind_traits<T7>::type,
-          typename bind_traits<T8>::type,
-          typename bind_traits<T9>::type> type;
-};
-
-// bind_traits, except map const T& -> const T
-  // this is needed e.g. in currying. Const reference arguments can
-  // refer to temporaries, so it is not safe to store them as references.
-  template <class T> struct remove_const_reference {
-    typedef typename bind_traits<T>::type type;
-  };
-
-  template <class T> struct remove_const_reference<const T&> {
-    typedef const T type;
-  };
-
-
-// maps the bind argument types to the resulting lambda functor type
-template <
-  class T0 = null_type, class T1 = null_type, class T2 = null_type, 
-  class T3 = null_type, class T4 = null_type, class T5 = null_type, 
-  class T6 = null_type, class T7 = null_type, class T8 = null_type, 
-  class T9 = null_type
->
-class bind_type_generator {
-
-  typedef typename
-  detail::bind_tuple_mapper<
-    T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
-  >::type args_t;
-
-  BOOST_STATIC_CONSTANT(int, nof_elems = boost::tuples::length<args_t>::value);
-
-  typedef 
-    action<
-      nof_elems, 
-      function_action<nof_elems>
-    > action_type;
-
-public:
-  typedef
-    lambda_functor<
-      lambda_functor_base<
-        action_type, 
-        args_t
-      >
-    > type; 
-    
-};
-
-
-   
-} // detail
-   
-template <class T> inline const T&  make_const(const T& t) { return t; }
-
-
-} // end of namespace lambda
-} // end of namespace boost
-
-
-   
-#endif // BOOST_LAMBDA_TRAITS_HPP
diff --git a/contrib/restricted/boost/boost/lambda/detail/member_ptr.hpp b/contrib/restricted/boost/boost/lambda/detail/member_ptr.hpp
deleted file mode 100644
index 288f70c5de..0000000000
--- a/contrib/restricted/boost/boost/lambda/detail/member_ptr.hpp
+++ /dev/null
@@ -1,737 +0,0 @@
-// Boost Lambda Library -- member_ptr.hpp ---------------------
-
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2000 Gary Powell (gary.powell@sierra.com)
-//
-// Distributed under 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)
-//
-// For more information, see www.boost.org
-
-// --------------------------------------------------------------------------
-
-#if !defined(BOOST_LAMBDA_MEMBER_PTR_HPP)
-#define BOOST_LAMBDA_MEMBER_PTR_HPP
-
-namespace boost { 
-namespace lambda {
-
-
-class member_pointer_action {};
-
-
-namespace detail {
-
-// the boost type_traits member_pointer traits are not enough, 
-// need to know more details.
-template<class T>
-struct member_pointer {
-  typedef typename boost::add_reference<T>::type type;
-  typedef detail::unspecified class_type;
-  typedef detail::unspecified qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = false);
-};
-
-template<class T, class U>
-struct member_pointer<T U::*> {
-  typedef typename boost::add_reference<T>::type type;
-  typedef U class_type;
-  typedef U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = true);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = false);
-};
-
-template<class T, class U>
-struct member_pointer<const T U::*> {
-  typedef typename boost::add_reference<const T>::type type;
-  typedef U class_type;
-  typedef const U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = true);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = false);
-};
-
-template<class T, class U>
-struct member_pointer<volatile T U::*> {
-  typedef typename boost::add_reference<volatile T>::type type;
-  typedef U class_type;
-  typedef volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = true);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = false);
-};
-
-template<class T, class U>
-struct member_pointer<const volatile T U::*> {
-  typedef typename boost::add_reference<const volatile T>::type type;
-  typedef U class_type;
-  typedef const volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = true);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = false);
-};
-
-// -- nonconst member functions --
-template<class T, class U>
-struct member_pointer<T (U::*)()> {
-  typedef T type;
-  typedef U class_type;
-  typedef U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1>
-struct member_pointer<T (U::*)(A1)> {
-  typedef T type;
-  typedef U class_type;
-  typedef U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2>
-struct member_pointer<T (U::*)(A1, A2)> {
-  typedef T type;
-  typedef U class_type;
-  typedef U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3>
-struct member_pointer<T (U::*)(A1, A2, A3)> {
-  typedef T type;
-  typedef U class_type;
-  typedef U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3, class A4>
-struct member_pointer<T (U::*)(A1, A2, A3, A4)> {
-  typedef T type;
-  typedef U class_type;
-  typedef U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3, class A4, class A5>
-struct member_pointer<T (U::*)(A1, A2, A3, A4, A5)> {
-  typedef T type;
-  typedef U class_type;
-  typedef U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3, class A4, class A5,
-         class A6>
-struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6)> {
-  typedef T type;
-  typedef U class_type;
-  typedef U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3, class A4, class A5,
-         class A6, class A7>
-struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7)> {
-  typedef T type;
-  typedef U class_type;
-  typedef U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3, class A4, class A5,
-         class A6, class A7, class A8>
-struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8)> {
-  typedef T type;
-  typedef U class_type;
-  typedef U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3, class A4, class A5,
-         class A6, class A7, class A8, class A9>
-struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
-  typedef T type;
-  typedef U class_type;
-  typedef U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-// -- const member functions --
-template<class T, class U>
-struct member_pointer<T (U::*)() const> {
-  typedef T type;
-  typedef U class_type;
-  typedef const U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1>
-struct member_pointer<T (U::*)(A1) const> {
-  typedef T type;
-  typedef U class_type;
-  typedef const U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2>
-struct member_pointer<T (U::*)(A1, A2) const> {
-  typedef T type;
-  typedef U class_type;
-  typedef const U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3>
-struct member_pointer<T (U::*)(A1, A2, A3) const> {
-  typedef T type;
-  typedef U class_type;
-  typedef const U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3, class A4>
-struct member_pointer<T (U::*)(A1, A2, A3, A4) const> {
-  typedef T type;
-  typedef U class_type;
-  typedef const U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3, class A4, class A5>
-struct member_pointer<T (U::*)(A1, A2, A3, A4, A5) const> {
-  typedef T type;
-  typedef U class_type;
-  typedef const U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3, class A4, class A5,
-         class A6>
-struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6) const> {
-  typedef T type;
-  typedef U class_type;
-  typedef const U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3, class A4, class A5,
-         class A6, class A7>
-struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7) const> {
-  typedef T type;
-  typedef U class_type;
-  typedef const U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3, class A4, class A5,
-         class A6, class A7, class A8>
-struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8) const> {
-  typedef T type;
-  typedef U class_type;
-  typedef const U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3, class A4, class A5,
-         class A6, class A7, class A8, class A9>
-struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const> {
-  typedef T type;
-  typedef U class_type;
-  typedef const U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-  // -- volatile --
-template<class T, class U>
-struct member_pointer<T (U::*)() volatile> {
-  typedef T type;
-  typedef U class_type;
-  typedef volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1>
-struct member_pointer<T (U::*)(A1) volatile> {
-  typedef T type;
-  typedef U class_type;
-  typedef volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2>
-struct member_pointer<T (U::*)(A1, A2) volatile> {
-  typedef T type;
-  typedef U class_type;
-  typedef volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3>
-struct member_pointer<T (U::*)(A1, A2, A3) volatile> {
-  typedef T type;
-  typedef U class_type;
-  typedef volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3, class A4>
-struct member_pointer<T (U::*)(A1, A2, A3, A4) volatile> {
-  typedef T type;
-  typedef U class_type;
-  typedef volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3, class A4, class A5>
-struct member_pointer<T (U::*)(A1, A2, A3, A4, A5) volatile> {
-  typedef T type;
-  typedef U class_type;
-  typedef volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3, class A4, class A5,
-         class A6>
-struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6) volatile> {
-  typedef T type;
-  typedef U class_type;
-  typedef volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3, class A4, class A5,
-         class A6, class A7>
-struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7) volatile> {
-  typedef T type;
-  typedef U class_type;
-  typedef volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3, class A4, class A5,
-         class A6, class A7, class A8>
-struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8) volatile> {
-  typedef T type;
-  typedef U class_type;
-  typedef volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3, class A4, class A5,
-         class A6, class A7, class A8, class A9>
-struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) volatile> {
-  typedef T type;
-  typedef U class_type;
-  typedef volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-  // -- const volatile
-template<class T, class U>
-struct member_pointer<T (U::*)() const volatile> {
-  typedef T type;
-  typedef U class_type;
-  typedef const volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1>
-struct member_pointer<T (U::*)(A1) const volatile> {
-  typedef T type;
-  typedef U class_type;
-  typedef const volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2>
-struct member_pointer<T (U::*)(A1, A2) const volatile> {
-  typedef T type;
-  typedef U class_type;
-  typedef const volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3>
-struct member_pointer<T (U::*)(A1, A2, A3) const volatile> {
-  typedef T type;
-  typedef U class_type;
-  typedef const volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3, class A4>
-struct member_pointer<T (U::*)(A1, A2, A3, A4) const volatile> {
-  typedef T type;
-  typedef U class_type;
-  typedef const volatile U qualified_class_type;
-};
-template<class T, class U, class A1, class A2, class A3, class A4, class A5>
-struct member_pointer<T (U::*)(A1, A2, A3, A4, A5) const volatile> {
-  typedef T type;
-  typedef U class_type;
-  typedef const volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3, class A4, class A5,
-         class A6>
-struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6) const volatile> {
-  typedef T type;
-  typedef U class_type;
-  typedef const volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3, class A4, class A5,
-         class A6, class A7>
-struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7) const volatile> {
-  typedef T type;
-  typedef U class_type;
-  typedef const volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3, class A4, class A5,
-         class A6, class A7, class A8>
-struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8) const volatile> {
-  typedef T type;
-  typedef U class_type;
-  typedef const volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-template<class T, class U, class A1, class A2, class A3, class A4, class A5,
-         class A6, class A7, class A8, class A9>
-struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const volatile> {
-  typedef T type;
-  typedef U class_type;
-  typedef const volatile U qualified_class_type;
-  BOOST_STATIC_CONSTANT(bool, is_data_member = false);
-  BOOST_STATIC_CONSTANT(bool, is_function_member = true);
-};
-
-} // detail
-
-namespace detail {
-
-  // this class holds a pointer to a member function and the object.
-  // when called, it just calls the member function with the parameters 
-  // provided
-
-  // It would have been possible to use existing lambda_functors to represent
-  // a bound member function like this, but to have a separate template is 
-  // safer, since now this functor doesn't mix and match with lambda_functors
-  // only thing you can do with this is to call it
-
-  // note that previously instantiated classes 
-  // (other_action<member_pointer_action> and member_pointer_action_helper
-  // guarantee, that A and B are 
-  // such types, that for objects a and b of corresponding types, a->*b leads 
-  // to the builtin ->* to be called. So types that would end in a  call to 
-  // a user defined ->* do not create a member_pointer_caller object.
-
-template<class RET, class A, class B>
-class member_pointer_caller {
-  A a; B b;
-
-public:
-  member_pointer_caller(const A& aa, const B& bb) : a(aa), b(bb) {}
-
-  RET operator()() const { return (a->*b)(); } 
-
-  template<class A1>
-  RET operator()(const A1& a1) const { return (a->*b)(a1); } 
-
-  template<class A1, class A2>
-  RET operator()(const A1& a1, const A2& a2) const { return (a->*b)(a1, a2); } 
-
-  template<class A1, class A2, class A3>
-  RET operator()(const A1& a1, const A2& a2, const A3& a3) const { 
-    return (a->*b)(a1, a2, a3); 
-  } 
-
-  template<class A1, class A2, class A3, class A4>
-  RET operator()(const A1& a1, const A2& a2, const A3& a3, 
-                 const A4& a4) const { 
-    return (a->*b)(a1, a2, a3, a4); 
-  } 
-
-  template<class A1, class A2, class A3, class A4, class A5>
-  RET operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 
-                 const A5& a5) const { 
-    return (a->*b)(a1, a2, a3, a4, a5); 
-  } 
-
-  template<class A1, class A2, class A3, class A4, class A5, class A6>
-  RET operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 
-                 const A5& a5, const A6& a6) const { 
-    return (a->*b)(a1, a2, a3, a4, a5, a6); 
-  } 
-
-  template<class A1, class A2, class A3, class A4, class A5, class A6, 
-           class A7>
-  RET operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 
-                 const A5& a5, const A6& a6, const A7& a7) const { 
-    return (a->*b)(a1, a2, a3, a4, a5, a6, a7); 
-  } 
-
-  template<class A1, class A2, class A3, class A4, class A5, class A6, 
-           class A7, class A8>
-  RET operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 
-                 const A5& a5, const A6& a6, const A7& a7,
-                 const A8& a8) const { 
-    return (a->*b)(a1, a2, a3, a4, a5, a6, a7, a8); 
-  } 
-
-  template<class A1, class A2, class A3, class A4, class A5, class A6, 
-           class A7, class A8, class A9>
-  RET operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, 
-                 const A5& a5, const A6& a6, const A7& a7,
-                 const A8& a8, const A9& a9) const { 
-    return (a->*b)(a1, a2, a3, a4, a5, a6, a7, a8, a9); 
-  } 
-
-};
-
-// helper templates for return type deduction and action classes
-// different cases for data member, function member, neither
-
-// true-true case
-template <bool Is_data_member, bool Is_function_member>
-struct member_pointer_action_helper;
-  // cannot be both, no body provided
-
-  // data member case
-  // this means, that B is a data member and A is a pointer type,
-  // so either built-in ->* should be called, or there is an error
-template <>
-struct member_pointer_action_helper<true, false> {
-public:
-
-  template<class RET, class A, class B>
-  static RET apply(A& a, B& b) { 
-    return a->*b; 
-  }
-
-  template<class A, class B>
-  struct return_type {
-  private:
-    typedef typename detail::remove_reference_and_cv<B>::type plainB;
-
-    typedef typename detail::member_pointer<plainB>::type type0;
-    // we remove the reference now, as we may have to add cv:s 
-    typedef typename boost::remove_reference<type0>::type type1;
-
-    // A is a reference to pointer
-    // remove the top level cv qualifiers and reference
-    typedef typename 
-      detail::remove_reference_and_cv<A>::type non_ref_A;
-
-    // A is a pointer type, so take the type pointed to
-    typedef typename ::boost::remove_pointer<non_ref_A>::type non_pointer_A; 
-
-  public:
-    // For non-reference types, we must add const and/or volatile if
-    // the pointer type has these qualifiers
-    // If the member is a reference, these do not have any effect
-    //   (cv T == T if T is a reference type)
-    typedef typename detail::IF<
-      ::boost::is_const<non_pointer_A>::value, 
-      typename ::boost::add_const<type1>::type,
-      type1
-    >::RET type2;
-    typedef typename detail::IF<
-      ::boost::is_volatile<non_pointer_A>::value, 
-      typename ::boost::add_volatile<type2>::type,
-      type2
-    >::RET type3;
-    // add reference back
-    typedef typename ::boost::add_reference<type3>::type type;
-  };
-};
-
-  // neither case
-template <>
-struct member_pointer_action_helper<false, false> {
-public:
-  template<class RET, class A, class B>
-  static RET apply(A& a, B& b) { 
-// not a built in member pointer operator, just call ->*
-    return a->*b; 
-  }
-  // an overloaded member pointer operators, user should have specified
-  // the return type
-  // At this point we know that there is no matching specialization for
-  // return_type_2, so try return_type_2_plain
-  template<class A, class B>
-  struct return_type {
-
-    typedef typename plain_return_type_2<
-      other_action<member_pointer_action>, A, B
-    >::type type;
-  };
-  
-};
-
-
-// member pointer function case
-// This is a built in ->* call for a member function, 
-// the only thing that you can do with that, is to give it some arguments
-// note, it is guaranteed that A is a pointer type, and thus it cannot
-// be a call to overloaded ->*
-template <>
-struct member_pointer_action_helper<false, true> {
-  public:
-
-  template<class RET, class A, class B>
-  static RET apply(A& a, B& b) { 
-    typedef typename ::boost::remove_cv<B>::type plainB;
-    typedef typename detail::member_pointer<plainB>::type ret_t; 
-    typedef typename ::boost::remove_cv<A>::type plainA;
-
-    // we always strip cv:s to 
-    // make the two routes (calling and type deduction)
-    // to give the same results (and the const does not make any functional
-    // difference)
-    return detail::member_pointer_caller<ret_t, plainA, plainB>(a, b); 
-  }
-
-  template<class A, class B>
-  struct return_type {
-    typedef typename detail::remove_reference_and_cv<B>::type plainB;
-    typedef typename detail::member_pointer<plainB>::type ret_t; 
-    typedef typename detail::remove_reference_and_cv<A>::type plainA; 
-
-    typedef detail::member_pointer_caller<ret_t, plainA, plainB> type; 
-  };
-};
-
-} // detail
-
-template<> class other_action<member_pointer_action>  {
-public:
-  template<class RET, class A, class B>
-  static RET apply(A& a, B& b) {
-    typedef typename 
-      ::boost::remove_cv<B>::type plainB;
-
-    return detail::member_pointer_action_helper<
-        boost::is_pointer<A>::value && 
-          detail::member_pointer<plainB>::is_data_member,
-        boost::is_pointer<A>::value && 
-          detail::member_pointer<plainB>::is_function_member
-      >::template apply<RET>(a, b); 
-    }
-};
-
-  // return type deduction --
-
-  // If the right argument is a pointer to data member, 
-  // and the left argument is of compatible pointer to class type
-  // return type is a reference to the data member type
-
-  // if right argument is a pointer to a member function, and the left 
-  // argument is of a compatible type, the return type is a 
-  // member_pointer_caller (see above)
-
-  // Otherwise, return type deduction fails. There is either an error, 
-  // or the user is trying to call an overloaded ->*
-  // In such a case either ret<> must be used, or a return_type_2 user 
-  // defined specialization must be provided
-
-
-template<class A, class B>
-struct return_type_2<other_action<member_pointer_action>, A, B> {
-private:
-  typedef typename 
-    detail::remove_reference_and_cv<B>::type plainB;
-public:
-  typedef typename 
-    detail::member_pointer_action_helper<
-      detail::member_pointer<plainB>::is_data_member,
-      detail::member_pointer<plainB>::is_function_member
-    >::template return_type<A, B>::type type; 
-};
-
-  // this is the way the generic lambda_functor_base functions instantiate
-  // return type deduction. We turn it into return_type_2, so that the 
-  // user can provide specializations on that level.
-template<class Args>
-struct return_type_N<other_action<member_pointer_action>, Args> {
-  typedef typename boost::tuples::element<0, Args>::type A;
-  typedef typename boost::tuples::element<1, Args>::type B;
-  typedef typename 
-    return_type_2<other_action<member_pointer_action>, 
-                  typename boost::remove_reference<A>::type, 
-                  typename boost::remove_reference<B>::type
-                 >::type type;
-};
-
-
-template<class Arg1, class Arg2>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<2, other_action<member_pointer_action> >,
-    tuple<lambda_functor<Arg1>, typename const_copy_argument<Arg2>::type>
-  >
->
-operator->*(const lambda_functor<Arg1>& a1, const Arg2& a2)
-{
-  return 
-      lambda_functor_base<
-        action<2, other_action<member_pointer_action> >,
-        tuple<lambda_functor<Arg1>, typename const_copy_argument<Arg2>::type>
-      >
-      (tuple<lambda_functor<Arg1>, 
-             typename const_copy_argument<Arg2>::type>(a1, a2));
-}
-
-template<class Arg1, class Arg2>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<2, other_action<member_pointer_action> >,
-    tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
-  >
->
-operator->*(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2)
-{
-  return 
-      lambda_functor_base<
-        action<2, other_action<member_pointer_action> >,
-        tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
-      >
-    (tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >(a1, a2));
-}
-
-template<class Arg1, class Arg2>
-inline const
-lambda_functor<
-  lambda_functor_base<
-    action<2, other_action<member_pointer_action> >,
-    tuple<typename const_copy_argument<Arg1>::type, lambda_functor<Arg2> >
-  >
->
-operator->*(const Arg1& a1, const lambda_functor<Arg2>& a2)
-{
-  return 
-      lambda_functor_base<
-        action<2, other_action<member_pointer_action> >,
-        tuple<typename const_copy_argument<Arg1>::type, lambda_functor<Arg2> >
-      >
-      (tuple<typename const_copy_argument<Arg1>::type, 
-             lambda_functor<Arg2> >(a1, a2));
-}
-
-
-} // namespace lambda 
-} // namespace boost
-
-
-#endif
-
-
-
-
-
-
diff --git a/contrib/restricted/boost/boost/lambda/detail/operator_actions.hpp b/contrib/restricted/boost/boost/lambda/detail/operator_actions.hpp
deleted file mode 100644
index 949b40fa43..0000000000
--- a/contrib/restricted/boost/boost/lambda/detail/operator_actions.hpp
+++ /dev/null
@@ -1,139 +0,0 @@
-// -- operator_actions.hpp - Boost Lambda Library ----------------------
-
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//
-// Distributed under 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)
-
-// For more information, see http://lambda.cs.utu.fi 
-
-#ifndef BOOST_LAMBDA_OPERATOR_ACTIONS_HPP
-#define BOOST_LAMBDA_OPERATOR_ACTIONS_HPP
-
-namespace boost { 
-namespace lambda {
-
-
-// -- artihmetic ----------------------
-
-class plus_action {};
-class minus_action {};
-class multiply_action {};
-class divide_action {};
-class remainder_action {};
-
-// -- bitwise  -------------------
-
-class leftshift_action {};
-class rightshift_action {};
-class xor_action {};
-
-
-// -- bitwise/logical -------------------
-
-class and_action {};
-class or_action {};
-class not_action {};
-
-// -- relational -------------------------
-
-class less_action {};
-class greater_action {};
-class lessorequal_action {};
-class greaterorequal_action {};
-class equal_action {};
-class notequal_action {};
-
-// -- increment/decrement ------------------------------
-
-class increment_action {};
-class decrement_action {};
-
-// -- void return ------------------------------
-
-// -- other  ------------------------------
-
-class addressof_action {};
-  // class comma_action {}; // defined in actions.hpp
-class contentsof_action {};
-// class member_pointer_action {}; (defined in member_ptr.hpp)
-
-
-// -- actioun group templates --------------------
-
-template <class Action> class arithmetic_action;
-template <class Action> class bitwise_action;
-template <class Action> class logical_action;
-template <class Action> class relational_action;
-template <class Action> class arithmetic_assignment_action;
-template <class Action> class bitwise_assignment_action;
-template <class Action> class unary_arithmetic_action;
-template <class Action> class pre_increment_decrement_action;
-template <class Action> class post_increment_decrement_action;
-
-// ---------------------------------------------------------
-
-  // actions, for which the existence of protect is checked in return type 
-  // deduction.
-
-template <class Act> struct is_protectable<arithmetic_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-template <class Act> struct is_protectable<bitwise_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-template <class Act> struct is_protectable<logical_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-template <class Act> struct is_protectable<relational_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-template <class Act> 
-struct is_protectable<arithmetic_assignment_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-template <class Act> struct is_protectable<bitwise_assignment_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-template <class Act> struct is_protectable<unary_arithmetic_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-template <class Act> 
-struct is_protectable<pre_increment_decrement_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-template <class Act> struct 
-is_protectable<post_increment_decrement_action<Act> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-
-template <> struct is_protectable<other_action<addressof_action> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-template <> struct is_protectable<other_action<contentsof_action> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-
-template<> struct is_protectable<other_action<subscript_action> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-template<> struct is_protectable<other_action<assignment_action> > {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-
-// NOTE: comma action is also protectable, but the specialization is
-  // in actions.hpp
-
-
-} // namespace lambda 
-} // namespace boost
-
-#endif
-
-
-
-
-
-
-
diff --git a/contrib/restricted/boost/boost/lambda/detail/operator_lambda_func_base.hpp b/contrib/restricted/boost/boost/lambda/detail/operator_lambda_func_base.hpp
deleted file mode 100644
index 12a6d934a4..0000000000
--- a/contrib/restricted/boost/boost/lambda/detail/operator_lambda_func_base.hpp
+++ /dev/null
@@ -1,271 +0,0 @@
-// Boost Lambda Library  - operator_lambda_func_base.hpp -----------------
-//
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//
-// Distributed under 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)
-//
-// For more information, see www.boost.org
-
-// ------------------------------------------------------------
-
-#ifndef BOOST_LAMBDA_OPERATOR_LAMBDA_FUNC_BASE_HPP
-#define BOOST_LAMBDA_OPERATOR_LAMBDA_FUNC_BASE_HPP
-
-namespace boost { 
-namespace lambda {
-
-
-// These operators cannot be implemented as apply functions of action 
-// templates
-
-
-// Specialization for comma.
-template<class Args>
-class lambda_functor_base<other_action<comma_action>, Args> {
-public:
-  Args args;
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS), 
-           detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); 
-  }
-
-
-  template<class SigArgs> struct sig { 
-  private:
-    typedef typename
-      detail::deduce_argument_types<Args, SigArgs>::type rets_t;      
-  public:
-    typedef typename return_type_2_comma< // comma needs special handling
-      typename detail::element_or_null<0, rets_t>::type,
-      typename detail::element_or_null<1, rets_t>::type
-    >::type type;
-  };
-
-};  
-
-namespace detail {
-
-// helper traits to make the expression shorter, takes binary action
-// bound argument tuple, open argument tuple and gives the return type
-
-template<class Action, class Bound, class Open> class binary_rt {
-  private:
-    typedef typename
-      detail::deduce_argument_types<Bound, Open>::type rets_t;      
-  public:
-    typedef typename return_type_2_prot<
-      Action,  
-      typename detail::element_or_null<0, rets_t>::type,
-      typename detail::element_or_null<1, rets_t>::type
-    >::type type;
-};
-
-
-  // same for unary actions
-template<class Action, class Bound, class Open> class unary_rt {
-  private:
-    typedef typename
-      detail::deduce_argument_types<Bound, Open>::type rets_t;      
-  public:
-    typedef typename return_type_1_prot<
-      Action,  
-      typename detail::element_or_null<0, rets_t>::type
-    >::type type;
-};
-
-
-} // end detail
-
-// Specialization for logical and (to preserve shortcircuiting)
-// this could be done with a macro as the others, code used to be different
-template<class Args>
-class lambda_functor_base<logical_action<and_action>, Args> {
-public:
-  Args args;
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) && 
-           detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); 
-  }
-  template<class SigArgs> struct sig { 
-    typedef typename
-      detail::binary_rt<logical_action<and_action>, Args, SigArgs>::type type;
-  };      
-};  
-
-// Specialization for logical or (to preserve shortcircuiting)
-// this could be done with a macro as the others, code used to be different
-template<class Args>
-class lambda_functor_base<logical_action< or_action>, Args> {
-public:
-  Args args;
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) || 
-           detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); 
-  }
-
-  template<class SigArgs> struct sig { 
-    typedef typename
-      detail::binary_rt<logical_action<or_action>, Args, SigArgs>::type type;
-  };      
-};  
-
-// Specialization for subscript
-template<class Args>
-class lambda_functor_base<other_action<subscript_action>, Args> {
-public:
-  Args args;
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) 
-           [detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS)]; 
-  }
-
-  template<class SigArgs> struct sig { 
-    typedef typename
-      detail::binary_rt<other_action<subscript_action>, Args, SigArgs>::type 
-        type;
-  };      
-};  
-
-
-#define BOOST_LAMBDA_BINARY_ACTION(SYMBOL, ACTION_CLASS)  \
-template<class Args>                                                      \
-class lambda_functor_base<ACTION_CLASS, Args> {                           \
-public:                                                                   \
-  Args args;                                                              \
-public:                                                                   \
-  explicit lambda_functor_base(const Args& a) : args(a) {}                \
-                                                                          \
-  template<class RET, CALL_TEMPLATE_ARGS>                                 \
-  RET call(CALL_FORMAL_ARGS) const {                                      \
-    return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS)  \
-           SYMBOL                                                         \
-           detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); \
-  }                                                                       \
-  template<class SigArgs> struct sig {                                    \
-    typedef typename                                                      \
-      detail::binary_rt<ACTION_CLASS, Args, SigArgs>::type type;          \
-  };                                                                      \
-};  
-
-#define BOOST_LAMBDA_PREFIX_UNARY_ACTION(SYMBOL, ACTION_CLASS)            \
-template<class Args>                                                      \
-class lambda_functor_base<ACTION_CLASS, Args> {                           \
-public:                                                                   \
-  Args args;                                                              \
-public:                                                                   \
-  explicit lambda_functor_base(const Args& a) : args(a) {}                \
-                                                                          \
-  template<class RET, CALL_TEMPLATE_ARGS>                                 \
-  RET call(CALL_FORMAL_ARGS) const {                                      \
-    return SYMBOL                                                         \
-           detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); \
-  }                                                                       \
-  template<class SigArgs> struct sig {                                    \
-    typedef typename                                                      \
-      detail::unary_rt<ACTION_CLASS, Args, SigArgs>::type type;           \
-  };                                                                      \
-};  
-
-#define BOOST_LAMBDA_POSTFIX_UNARY_ACTION(SYMBOL, ACTION_CLASS)           \
-template<class Args>                                                      \
-class lambda_functor_base<ACTION_CLASS, Args> {                           \
-public:                                                                   \
-  Args args;                                                              \
-public:                                                                   \
-  explicit lambda_functor_base(const Args& a) : args(a) {}                \
-                                                                          \
-  template<class RET, CALL_TEMPLATE_ARGS>                                 \
-  RET call(CALL_FORMAL_ARGS) const {                                      \
-    return                                                                \
-    detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) SYMBOL; \
-  }                                                                       \
-  template<class SigArgs> struct sig {                                    \
-    typedef typename                                                      \
-      detail::unary_rt<ACTION_CLASS, Args, SigArgs>::type type;           \
-  };                                                                      \
-};  
-
-BOOST_LAMBDA_BINARY_ACTION(+,arithmetic_action<plus_action>)
-BOOST_LAMBDA_BINARY_ACTION(-,arithmetic_action<minus_action>)
-BOOST_LAMBDA_BINARY_ACTION(*,arithmetic_action<multiply_action>)
-BOOST_LAMBDA_BINARY_ACTION(/,arithmetic_action<divide_action>)
-BOOST_LAMBDA_BINARY_ACTION(%,arithmetic_action<remainder_action>)
-
-BOOST_LAMBDA_BINARY_ACTION(<<,bitwise_action<leftshift_action>)
-BOOST_LAMBDA_BINARY_ACTION(>>,bitwise_action<rightshift_action>)
-BOOST_LAMBDA_BINARY_ACTION(&,bitwise_action<and_action>)
-BOOST_LAMBDA_BINARY_ACTION(|,bitwise_action<or_action>)
-BOOST_LAMBDA_BINARY_ACTION(^,bitwise_action<xor_action>)
-
-BOOST_LAMBDA_BINARY_ACTION(<,relational_action<less_action>)
-BOOST_LAMBDA_BINARY_ACTION(>,relational_action<greater_action>)
-BOOST_LAMBDA_BINARY_ACTION(<=,relational_action<lessorequal_action>)
-BOOST_LAMBDA_BINARY_ACTION(>=,relational_action<greaterorequal_action>)
-BOOST_LAMBDA_BINARY_ACTION(==,relational_action<equal_action>)
-BOOST_LAMBDA_BINARY_ACTION(!=,relational_action<notequal_action>)
-
-BOOST_LAMBDA_BINARY_ACTION(+=,arithmetic_assignment_action<plus_action>)
-BOOST_LAMBDA_BINARY_ACTION(-=,arithmetic_assignment_action<minus_action>)
-BOOST_LAMBDA_BINARY_ACTION(*=,arithmetic_assignment_action<multiply_action>)
-BOOST_LAMBDA_BINARY_ACTION(/=,arithmetic_assignment_action<divide_action>)
-BOOST_LAMBDA_BINARY_ACTION(%=,arithmetic_assignment_action<remainder_action>)
-
-BOOST_LAMBDA_BINARY_ACTION(<<=,bitwise_assignment_action<leftshift_action>)
-BOOST_LAMBDA_BINARY_ACTION(>>=,bitwise_assignment_action<rightshift_action>)
-BOOST_LAMBDA_BINARY_ACTION(&=,bitwise_assignment_action<and_action>)
-BOOST_LAMBDA_BINARY_ACTION(|=,bitwise_assignment_action<or_action>)
-BOOST_LAMBDA_BINARY_ACTION(^=,bitwise_assignment_action<xor_action>)
-
-BOOST_LAMBDA_BINARY_ACTION(=,other_action< assignment_action>)
-
-
-BOOST_LAMBDA_PREFIX_UNARY_ACTION(+, unary_arithmetic_action<plus_action>)
-BOOST_LAMBDA_PREFIX_UNARY_ACTION(-, unary_arithmetic_action<minus_action>)
-BOOST_LAMBDA_PREFIX_UNARY_ACTION(~, bitwise_action<not_action>)
-BOOST_LAMBDA_PREFIX_UNARY_ACTION(!, logical_action<not_action>)
-BOOST_LAMBDA_PREFIX_UNARY_ACTION(++, pre_increment_decrement_action<increment_action>)
-BOOST_LAMBDA_PREFIX_UNARY_ACTION(--, pre_increment_decrement_action<decrement_action>)
-
-BOOST_LAMBDA_PREFIX_UNARY_ACTION(&,other_action<addressof_action>)
-BOOST_LAMBDA_PREFIX_UNARY_ACTION(*,other_action<contentsof_action>)
-
-BOOST_LAMBDA_POSTFIX_UNARY_ACTION(++, post_increment_decrement_action<increment_action>)
-BOOST_LAMBDA_POSTFIX_UNARY_ACTION(--, post_increment_decrement_action<decrement_action>)
-
-
-#undef BOOST_LAMBDA_POSTFIX_UNARY_ACTION
-#undef BOOST_LAMBDA_PREFIX_UNARY_ACTION
-#undef BOOST_LAMBDA_BINARY_ACTION
-
-} // namespace lambda
-} // namespace boost
-
-#endif
-
-
-
-
-
-
-
-
-
-
diff --git a/contrib/restricted/boost/boost/lambda/detail/operator_return_type_traits.hpp b/contrib/restricted/boost/boost/lambda/detail/operator_return_type_traits.hpp
deleted file mode 100644
index 6af4d03671..0000000000
--- a/contrib/restricted/boost/boost/lambda/detail/operator_return_type_traits.hpp
+++ /dev/null
@@ -1,892 +0,0 @@
-//  operator_return_type_traits.hpp -- Boost Lambda Library ------------------
-
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//
-// Distributed under 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)
-//
-// For more information, see www.boost.org
-
-#ifndef BOOST_LAMBDA_OPERATOR_RETURN_TYPE_TRAITS_HPP
-#define BOOST_LAMBDA_OPERATOR_RETURN_TYPE_TRAITS_HPP
-
-#include "boost/lambda/detail/is_instance_of.hpp"
-#include "boost/type_traits/is_same.hpp"
-#include "boost/type_traits/is_pointer.hpp"
-#include "boost/type_traits/is_float.hpp"
-#include "boost/type_traits/is_convertible.hpp"
-#include "boost/type_traits/remove_pointer.hpp"
-#include "boost/type_traits/remove_const.hpp"
-#include "boost/type_traits/remove_reference.hpp"
-
-#include "boost/indirect_reference.hpp"
-#include "boost/detail/container_fwd.hpp"
-
-#include <cstddef> // needed for the ptrdiff_t
-#include <iosfwd>  // for istream and ostream
-
-#include <iterator> // needed for operator&
-
-namespace boost { 
-namespace lambda {
-namespace detail {
-
-// -- general helper templates for type deduction ------------------
-
-// Much of the type deduction code for standard arithmetic types from Gary Powell
-
-template <class A> struct promote_code { static const int value = -1; };
-// this means that a code is not defined for A
-
-// -- the next 5 types are needed in if_then_else_return 
-// the promotion order is not important, but they must have distinct values.
-template <> struct promote_code<bool> { static const int value = 10; };
-template <> struct promote_code<char> { static const int value = 20; };
-template <> struct promote_code<unsigned char> { static const int value = 30; };
-template <> struct promote_code<signed char> { static const int value = 40; };
-template <> struct promote_code<short int> { static const int value = 50; };
-// ----------
-
-template <> struct promote_code<int> { static const int value = 100; };
-template <> struct promote_code<unsigned int> { static const int value = 200; };
-template <> struct promote_code<long> { static const int value = 300; };
-template <> struct promote_code<unsigned long> { static const int value = 400; };
-
-template <> struct promote_code<float> { static const int value = 500; };
-template <> struct promote_code<double> { static const int value = 600; };
-template <> struct promote_code<long double> { static const int value = 700; };
-
-// TODO: wchar_t
-
-// forward delcaration of complex.
-
-} // namespace detail
-} // namespace lambda 
-} // namespace boost
-
-namespace boost { 
-namespace lambda {
-namespace detail {
-
-template <> struct promote_code< std::complex<float> > { static const int value = 800; };
-template <> struct promote_code< std::complex<double> > { static const int value = 900; };
-template <> struct promote_code< std::complex<long double> > { static const int value = 1000; };
-
-// -- int promotion -------------------------------------------
-template <class T> struct promote_to_int { typedef T type; };
-
-template <> struct promote_to_int<bool> { typedef int type; };
-template <> struct promote_to_int<char> { typedef int type; };
-template <> struct promote_to_int<unsigned char> { typedef int type; };
-template <> struct promote_to_int<signed char> { typedef int type; };
-template <> struct promote_to_int<short int> { typedef int type; };
-
-// The unsigned short int promotion rule is this:
-// unsigned short int to signed int if a signed int can hold all values 
-// of unsigned short int, otherwise go to unsigned int.
-template <> struct promote_to_int<unsigned short int>
-{ 
-        typedef
-                detail::IF<sizeof(int) <= sizeof(unsigned short int),        
-// I had the logic reversed but ">" messes up the parsing.
-                unsigned int,
-                int>::RET type; 
-};
-
-
-// TODO: think, should there be default behaviour for non-standard types?
-
-} // namespace detail
-
-// ------------------------------------------ 
-// Unary actions ----------------------------
-// ------------------------------------------ 
-
-template<class Act, class A>
-struct plain_return_type_1 {
-  typedef detail::unspecified type;
-};
-
-
-
-template<class Act, class A>
-struct plain_return_type_1<unary_arithmetic_action<Act>, A> {
-  typedef A type;
-};
-
-template<class Act, class A> 
-struct return_type_1<unary_arithmetic_action<Act>, A> { 
-  typedef 
-    typename plain_return_type_1<
-      unary_arithmetic_action<Act>,
-      typename detail::remove_reference_and_cv<A>::type
-    >::type type;
-};
-
-
-template<class A>
-struct plain_return_type_1<bitwise_action<not_action>, A> {
-  typedef A type;
-};
-
-// bitwise not, operator~()
-template<class A> struct return_type_1<bitwise_action<not_action>, A> {
-  typedef 
-    typename plain_return_type_1<
-      bitwise_action<not_action>,
-      typename detail::remove_reference_and_cv<A>::type
-    >::type type;
-};
-
-
-// prefix increment and decrement operators return 
-// their argument by default as a non-const reference
-template<class Act, class A> 
-struct plain_return_type_1<pre_increment_decrement_action<Act>, A> {
-  typedef A& type;
-};
-
-template<class Act, class A> 
-struct return_type_1<pre_increment_decrement_action<Act>, A> {
-  typedef 
-    typename plain_return_type_1<
-      pre_increment_decrement_action<Act>,
-      typename detail::remove_reference_and_cv<A>::type
-    >::type type;
-};
-
-// post decrement just returns the same plain type.
-template<class Act, class A>
-struct plain_return_type_1<post_increment_decrement_action<Act>, A> {
-  typedef A type;
-};
-
-template<class Act, class A> 
-struct return_type_1<post_increment_decrement_action<Act>, A> 
-{ 
-  typedef 
-    typename plain_return_type_1<
-      post_increment_decrement_action<Act>,
-      typename detail::remove_reference_and_cv<A>::type
-    >::type type;
-};
-
-// logical not, operator!()
-template<class A> 
-struct plain_return_type_1<logical_action<not_action>, A> {
-  typedef bool type;
-};
-
-template<class A>
-struct return_type_1<logical_action<not_action>, A> {
-  typedef 
-    typename plain_return_type_1<
-      logical_action<not_action>,
-      typename detail::remove_reference_and_cv<A>::type
-    >::type type;
-};
-
-// address of action ---------------------------------------
-
-
-template<class A> 
-struct return_type_1<other_action<addressof_action>, A> { 
-  typedef 
-    typename plain_return_type_1<
-      other_action<addressof_action>, 
-      typename detail::remove_reference_and_cv<A>::type
-    >::type type1;
-
-  // If no user defined specialization for A, then return the
-  // cv qualified pointer to A
-  typedef typename detail::IF<
-    boost::is_same<type1, detail::unspecified>::value, 
-    typename boost::remove_reference<A>::type*,
-    type1
-  >::RET type;
-};
-
-// contentsof action ------------------------------------
-
-// TODO: this deduction may lead to fail directly, 
-// (if A has no specialization for iterator_traits and has no
-// typedef A::reference.
-// There is no easy way around this, cause there doesn't seem to be a way
-// to test whether a class is an iterator or not.
- 
-// The default works with std::iterators.
-
-namespace detail {
-
-  // A is a nonreference type
-template <class A> struct contentsof_type {
-  typedef typename boost::indirect_reference<A>::type type; 
-};
-
-  // this is since the nullary () in lambda_functor is always instantiated
-template <> struct contentsof_type<null_type> {
-  typedef detail::unspecified type;
-};
-
-
-template <class A> struct contentsof_type<const A> {
-  typedef typename contentsof_type<A>::type type;
-};
-
-template <class A> struct contentsof_type<volatile A> {
-  typedef typename contentsof_type<A>::type type;
-};
-
-template <class A> struct contentsof_type<const volatile A> {
-  typedef typename contentsof_type<A>::type type;
-};
-
-  // standard iterator traits should take care of the pointer types 
-  // but just to be on the safe side, we have the specializations here:
-  // these work even if A is cv-qualified.
-template <class A> struct contentsof_type<A*> {
-  typedef A& type;
-};
-template <class A> struct contentsof_type<A* const> {
-  typedef A& type;
-};
-template <class A> struct contentsof_type<A* volatile> {
-  typedef A& type;
-};
-template <class A> struct contentsof_type<A* const volatile> {
-  typedef A& type;
-};
-
-template<class A, int N> struct contentsof_type<A[N]> { 
-  typedef A& type; 
-};
-template<class A, int N> struct contentsof_type<const A[N]> { 
-  typedef const A& type; 
-};
-template<class A, int N> struct contentsof_type<volatile A[N]> { 
-  typedef volatile A& type; 
-};
-template<class A, int N> struct contentsof_type<const volatile A[N]> { 
-  typedef const volatile A& type; 
-};
-
-
-
-
-
-} // end detail
-
-template<class A> 
-struct return_type_1<other_action<contentsof_action>, A> { 
-
-  typedef 
-    typename plain_return_type_1<
-      other_action<contentsof_action>, 
-      typename detail::remove_reference_and_cv<A>::type
-    >::type type1;
-
-  // If no user defined specialization for A, then return the
-  // cv qualified pointer to A
-  typedef typename 
-  detail::IF_type<
-    boost::is_same<type1, detail::unspecified>::value, 
-    detail::contentsof_type<
-      typename boost::remove_reference<A>::type
-    >,
-    detail::identity_mapping<type1>
-  >::type type;
-};
-
-
-// ------------------------------------------------------------------
-// binary actions ---------------------------------------------------
-// ------------------------------------------------------------------
-
-// here the default case is: no user defined versions:
-template <class Act, class A, class B>
-struct plain_return_type_2 {
-  typedef detail::unspecified type; 
-};
-
-namespace detail {
-
-// error classes
-class illegal_pointer_arithmetic{};
-
-// pointer arithmetic type deductions ----------------------
-// value = false means that this is not a pointer arithmetic case
-// value = true means, that this can be a pointer arithmetic case, but not necessarily is
-// This means, that for user defined operators for pointer types, say for some operator+(X, *Y),
-// the deductions must be coded at an earliel level (return_type_2).
-
-template<class Act, class A, class B> 
-struct pointer_arithmetic_traits { static const bool value = false; };
-
-template<class A, class B> 
-struct pointer_arithmetic_traits<plus_action, A, B> { 
-
-  typedef typename 
-    array_to_pointer<typename boost::remove_reference<A>::type>::type AP;
-  typedef typename 
-    array_to_pointer<typename boost::remove_reference<B>::type>::type BP;
-
-  static const bool is_pointer_A = boost::is_pointer<AP>::value;
-  static const bool is_pointer_B = boost::is_pointer<BP>::value;  
-
-  static const bool value = is_pointer_A || is_pointer_B;
-
-  // can't add two pointers.
-  // note, that we do not check wether the other type is valid for 
-  // addition with a pointer.
-  // the compiler will catch it in the apply function
-
-  typedef typename 
-  detail::IF<
-    is_pointer_A && is_pointer_B, 
-      detail::return_type_deduction_failure<
-        detail::illegal_pointer_arithmetic
-      >,
-      typename detail::IF<is_pointer_A, AP, BP>::RET
-  >::RET type; 
-
-};
-
-template<class A, class B> 
-struct pointer_arithmetic_traits<minus_action, A, B> { 
-  typedef typename 
-    array_to_pointer<typename boost::remove_reference<A>::type>::type AP;
-  typedef typename 
-    array_to_pointer<typename boost::remove_reference<B>::type>::type BP;
-
-  static const bool is_pointer_A = boost::is_pointer<AP>::value;
-  static const bool is_pointer_B = boost::is_pointer<BP>::value;  
-
-  static const bool value = is_pointer_A || is_pointer_B;
-
-  static const bool same_pointer_type =
-    is_pointer_A && is_pointer_B && 
-    boost::is_same<
-      typename boost::remove_const<
-        typename boost::remove_pointer<
-          typename boost::remove_const<AP>::type
-        >::type
-      >::type,
-      typename boost::remove_const<
-        typename boost::remove_pointer<
-          typename boost::remove_const<BP>::type
-        >::type
-      >::type
-    >::value;
-
-  // ptr - ptr has type ptrdiff_t
-  // note, that we do not check if, in ptr - B, B is 
-  // valid for subtraction with a pointer.
-  // the compiler will catch it in the apply function
-
-  typedef typename 
-  detail::IF<
-    same_pointer_type, const std::ptrdiff_t,
-    typename detail::IF<
-      is_pointer_A, 
-      AP, 
-      detail::return_type_deduction_failure<detail::illegal_pointer_arithmetic>
-    >::RET
-  >::RET type; 
-};
-
-} // namespace detail
-   
-// -- arithmetic actions ---------------------------------------------
-
-namespace detail {
-   
-template<bool is_pointer_arithmetic, class Act, class A, class B> 
-struct return_type_2_arithmetic_phase_1;
-
-template<class A, class B> struct return_type_2_arithmetic_phase_2;
-template<class A, class B> struct return_type_2_arithmetic_phase_3;
-
-} // namespace detail
-  
-
-// drop any qualifiers from the argument types within arithmetic_action
-template<class A, class B, class Act> 
-struct return_type_2<arithmetic_action<Act>, A, B>
-{
-  typedef typename detail::remove_reference_and_cv<A>::type plain_A;
-  typedef typename detail::remove_reference_and_cv<B>::type plain_B;
-
-  typedef typename 
-    plain_return_type_2<arithmetic_action<Act>, plain_A, plain_B>::type type1;
-  
-  // if user defined return type, do not enter the whole arithmetic deductions
-  typedef typename 
-    detail::IF_type<
-      boost::is_same<type1, detail::unspecified>::value, 
-      detail::return_type_2_arithmetic_phase_1<
-         detail::pointer_arithmetic_traits<Act, A, B>::value, Act, A, B
-      >,
-      plain_return_type_2<arithmetic_action<Act>, plain_A, plain_B>
-    >::type type;
-};
-
-namespace detail {
-   
-// perform integral promotion, no pointer arithmetic
-template<bool is_pointer_arithmetic, class Act, class A, class B> 
-struct return_type_2_arithmetic_phase_1
-{
-  typedef typename 
-    return_type_2_arithmetic_phase_2<
-      typename remove_reference_and_cv<A>::type,
-      typename remove_reference_and_cv<B>::type
-    >::type type;
-};
-
-// pointer_arithmetic
-template<class Act, class A, class B> 
-struct return_type_2_arithmetic_phase_1<true, Act, A, B>
-{
-  typedef typename 
-    pointer_arithmetic_traits<Act, A, B>::type type;
-};
-
-template<class A, class B>
-struct return_type_2_arithmetic_phase_2 {
-  typedef typename
-    return_type_2_arithmetic_phase_3<
-      typename promote_to_int<A>::type, 
-      typename promote_to_int<B>::type
-    >::type type;
-};
-
-// specialization for unsigned int.
-// We only have to do these two specialization because the value promotion will
-// take care of the other cases.
-// The unsigned int promotion rule is this:
-// unsigned int to long if a long can hold all values of unsigned int,
-// otherwise go to unsigned long.
-
-// struct so I don't have to type this twice.
-struct promotion_of_unsigned_int
-{
-        typedef
-        detail::IF<sizeof(long) <= sizeof(unsigned int),        
-                unsigned long,
-                long>::RET type; 
-};
-
-template<>
-struct return_type_2_arithmetic_phase_2<unsigned int, long>
-{
-        typedef promotion_of_unsigned_int::type type;
-};
-template<>
-struct return_type_2_arithmetic_phase_2<long, unsigned int>
-{
-        typedef promotion_of_unsigned_int::type type;
-};
-
-
-template<class A, class B> struct return_type_2_arithmetic_phase_3 { 
-   enum { promote_code_A_value = promote_code<A>::value,
-         promote_code_B_value = promote_code<B>::value }; // enums for KCC
-  typedef typename
-    detail::IF<
-      promote_code_A_value == -1 || promote_code_B_value == -1,
-      detail::return_type_deduction_failure<return_type_2_arithmetic_phase_3>,
-      typename detail::IF<
-        ((int)promote_code_A_value > (int)promote_code_B_value), 
-        A, 
-        B
-      >::RET
-    >::RET type;                    
-};
-
-} // namespace detail
-
-// --  bitwise actions -------------------------------------------
-// note: for integral types deuduction is similar to arithmetic actions. 
-
-// drop any qualifiers from the argument types within arithmetic action
-template<class A, class B, class Act> 
-struct return_type_2<bitwise_action<Act>, A, B>
-{
-
-  typedef typename detail::remove_reference_and_cv<A>::type plain_A;
-  typedef typename detail::remove_reference_and_cv<B>::type plain_B;
-
-  typedef typename 
-    plain_return_type_2<bitwise_action<Act>, plain_A, plain_B>::type type1;
-  
-  // if user defined return type, do not enter type deductions
-  typedef typename 
-    detail::IF_type<
-      boost::is_same<type1, detail::unspecified>::value, 
-      return_type_2<arithmetic_action<plus_action>, A, B>,
-      plain_return_type_2<bitwise_action<Act>, plain_A, plain_B>
-    >::type type;
-
-  // plus_action is just a random pick, has to be a concrete instance
-
-  // TODO: This check is only valid for built-in types, overloaded types might
-  // accept floating point operators
-
-  // bitwise operators not defined for floating point types
-  // these test are not strictly needed here, since the error will be caught in
-  // the apply function
-  BOOST_STATIC_ASSERT(!(boost::is_float<plain_A>::value && boost::is_float<plain_B>::value));
-
-};
-
-namespace detail {
-
-
-template <class T> struct get_ostream_type {
-  typedef std::basic_ostream<typename T::char_type, 
-                             typename T::traits_type>& type;
-};
-
-template <class T> struct get_istream_type {
-  typedef std::basic_istream<typename T::char_type, 
-                             typename T::traits_type>& type;
-};
-
-template<class A, class B>
-struct leftshift_type {
-private:
-  typedef typename boost::remove_reference<A>::type plainA;
-public:
-  typedef typename detail::IF_type<
-    is_instance_of_2<plainA, std::basic_ostream>::value, 
-    get_ostream_type<plainA>, //reference to the stream 
-    detail::remove_reference_and_cv<A>
-  >::type type;
-};
-
-template<class A, class B>
-struct rightshift_type {
-private:
-  typedef typename boost::remove_reference<A>::type plainA;
-public:
-  typedef typename detail::IF_type<
-    is_instance_of_2<plainA, std::basic_istream>::value, 
-    get_istream_type<plainA>, //reference to the stream 
-    detail::remove_reference_and_cv<A>
-  >::type type;
-};
-
-
-
-} // end detail
-
-// ostream
-template<class A, class B> 
-struct return_type_2<bitwise_action<leftshift_action>, A, B>
-{
-  typedef typename detail::remove_reference_and_cv<A>::type plain_A;
-  typedef typename detail::remove_reference_and_cv<B>::type plain_B;
-
-  typedef typename 
-    plain_return_type_2<bitwise_action<leftshift_action>, plain_A, plain_B>::type type1;
-  
-  // if user defined return type, do not enter type deductions
-  typedef typename 
-    detail::IF_type<
-      boost::is_same<type1, detail::unspecified>::value, 
-      detail::leftshift_type<A, B>,
-      plain_return_type_2<bitwise_action<leftshift_action>, plain_A, plain_B>
-    >::type type;
-};
-
-// istream
-template<class A, class B> 
-struct return_type_2<bitwise_action<rightshift_action>, A, B>
-{
-  typedef typename detail::remove_reference_and_cv<A>::type plain_A;
-  typedef typename detail::remove_reference_and_cv<B>::type plain_B;
-
-  typedef typename 
-    plain_return_type_2<bitwise_action<rightshift_action>, plain_A, plain_B>::type type1;
-  
-  // if user defined return type, do not enter type deductions
-  typedef typename 
-    detail::IF_type<
-      boost::is_same<type1, detail::unspecified>::value, 
-      detail::rightshift_type<A, B>,
-      plain_return_type_2<bitwise_action<rightshift_action>, plain_A, plain_B>
-    >::type type;
-};
-
-// -- logical actions ----------------------------------------
-// always bool
-// NOTE: this may not be true for some weird user-defined types,
-template<class A, class B, class Act> 
-struct plain_return_type_2<logical_action<Act>, A, B> { 
-  typedef bool type; 
-};
-
-template<class A, class B, class Act> 
-struct return_type_2<logical_action<Act>, A, B> { 
-
-  typedef typename detail::remove_reference_and_cv<A>::type plain_A;
-  typedef typename detail::remove_reference_and_cv<B>::type plain_B;
-
-  typedef typename 
-    plain_return_type_2<logical_action<Act>, plain_A, plain_B>::type type;
-  
-};
-
-
-// -- relational actions ----------------------------------------
-// always bool
-// NOTE: this may not be true for some weird user-defined types,
-template<class A, class B, class Act> 
-struct plain_return_type_2<relational_action<Act>, A, B> { 
-  typedef bool type; 
-};
-
-template<class A, class B, class Act> 
-struct return_type_2<relational_action<Act>, A, B> { 
-
-  typedef typename detail::remove_reference_and_cv<A>::type plain_A;
-  typedef typename detail::remove_reference_and_cv<B>::type plain_B;
-
-  typedef typename 
-    plain_return_type_2<relational_action<Act>, plain_A, plain_B>::type type; 
-};
-
-// Assingment actions -----------------------------------------------
-// return type is the type of the first argument as reference
-
-// note that cv-qualifiers are preserved.
-// Yes, assignment operator can be const!
-
-// NOTE: this may not be true for some weird user-defined types,
-
-template<class A, class B, class Act> 
-struct return_type_2<arithmetic_assignment_action<Act>, A, B> { 
-
-  typedef typename detail::remove_reference_and_cv<A>::type plain_A;
-  typedef typename detail::remove_reference_and_cv<B>::type plain_B;
-
-  typedef typename 
-    plain_return_type_2<
-      arithmetic_assignment_action<Act>, plain_A, plain_B
-    >::type type1;
-  
-  typedef typename 
-    detail::IF<
-      boost::is_same<type1, detail::unspecified>::value, 
-      typename boost::add_reference<A>::type,
-      type1
-    >::RET type;
-};
-
-template<class A, class B, class Act> 
-struct return_type_2<bitwise_assignment_action<Act>, A, B> { 
-
-  typedef typename detail::remove_reference_and_cv<A>::type plain_A;
-  typedef typename detail::remove_reference_and_cv<B>::type plain_B;
-
-  typedef typename 
-    plain_return_type_2<
-      bitwise_assignment_action<Act>, plain_A, plain_B
-    >::type type1;
-  
-  typedef typename 
-    detail::IF<
-      boost::is_same<type1, detail::unspecified>::value, 
-      typename boost::add_reference<A>::type,
-      type1
-    >::RET type;
-};
-
-template<class A, class B> 
-struct return_type_2<other_action<assignment_action>, A, B> { 
-  typedef typename detail::remove_reference_and_cv<A>::type plain_A;
-  typedef typename detail::remove_reference_and_cv<B>::type plain_B;
-
-  typedef typename 
-    plain_return_type_2<
-      other_action<assignment_action>, plain_A, plain_B
-    >::type type1;
-  
-  typedef typename 
-    detail::IF<
-      boost::is_same<type1, detail::unspecified>::value, 
-      typename boost::add_reference<A>::type,
-      type1
-    >::RET type;
-};
-
-// -- other actions ----------------------------------------
-
-// comma action ----------------------------------
-// Note: this may not be true for some weird user-defined types,
-
-// NOTE! This only tries the plain_return_type_2 layer and gives
-// detail::unspecified as default. If no such specialization is found, the 
-// type rule in the spcecialization of the return_type_2_prot is used
-// to give the type of the right argument (which can be a reference too)
-// (The built in operator, can return a l- or rvalue).
-template<class A, class B> 
-struct return_type_2<other_action<comma_action>, A, B> { 
-
-  typedef typename detail::remove_reference_and_cv<A>::type plain_A;
-  typedef typename detail::remove_reference_and_cv<B>::type plain_B;
-
-  typedef typename 
-    plain_return_type_2<
-      other_action<comma_action>, plain_A, plain_B
-    >::type type;
-  };
-
-// subscript action -----------------------------------------------
-
-
-namespace detail {
-  // A and B are nonreference types
-template <class A, class B> struct subscript_type {
-  typedef detail::unspecified type; 
-};
-
-template <class A, class B> struct subscript_type<A*, B> {
-  typedef A& type;
-};
-template <class A, class B> struct subscript_type<A* const, B> {
-  typedef A& type;
-};
-template <class A, class B> struct subscript_type<A* volatile, B> {
-  typedef A& type;
-};
-template <class A, class B> struct subscript_type<A* const volatile, B> {
-  typedef A& type;
-};
-
-
-template<class A, class B, int N> struct subscript_type<A[N], B> { 
-  typedef A& type; 
-};
-
-  // these 3 specializations are needed to make gcc <3 happy
-template<class A, class B, int N> struct subscript_type<const A[N], B> { 
-  typedef const A& type; 
-};
-template<class A, class B, int N> struct subscript_type<volatile A[N], B> { 
-  typedef volatile A& type; 
-};
-template<class A, class B, int N> struct subscript_type<const volatile A[N], B> { 
-  typedef const volatile A& type; 
-};
-
-} // end detail
-
-template<class A, class B>
-struct return_type_2<other_action<subscript_action>, A, B> {
-
-  typedef typename detail::remove_reference_and_cv<A>::type plain_A;
-  typedef typename detail::remove_reference_and_cv<B>::type plain_B;
-
-  typedef typename boost::remove_reference<A>::type nonref_A;
-  typedef typename boost::remove_reference<B>::type nonref_B;
-
-  typedef typename 
-    plain_return_type_2<
-      other_action<subscript_action>, plain_A, plain_B
-    >::type type1;
-  
-  typedef typename 
-    detail::IF_type<
-      boost::is_same<type1, detail::unspecified>::value, 
-      detail::subscript_type<nonref_A, nonref_B>,
-      plain_return_type_2<other_action<subscript_action>, plain_A, plain_B>
-    >::type type;
-
-};
-
-template<class Key, class T, class Cmp, class Allocator, class B> 
-struct plain_return_type_2<other_action<subscript_action>, std::map<Key, T, Cmp, Allocator>, B> { 
-  typedef T& type;
-  // T == std::map<Key, T, Cmp, Allocator>::mapped_type; 
-};
-
-template<class Key, class T, class Cmp, class Allocator, class B> 
-struct plain_return_type_2<other_action<subscript_action>, std::multimap<Key, T, Cmp, Allocator>, B> { 
-  typedef T& type;
-  // T == std::map<Key, T, Cmp, Allocator>::mapped_type; 
-};
-
-  // deque
-template<class T, class Allocator, class B> 
-struct plain_return_type_2<other_action<subscript_action>, std::deque<T, Allocator>, B> { 
-  typedef typename std::deque<T, Allocator>::reference type;
-};
-template<class T, class Allocator, class B> 
-struct plain_return_type_2<other_action<subscript_action>, const std::deque<T, Allocator>, B> { 
-  typedef typename std::deque<T, Allocator>::const_reference type;
-};
-
-  // vector
-template<class T, class Allocator, class B> 
-struct plain_return_type_2<other_action<subscript_action>, std::vector<T, Allocator>, B> { 
-  typedef typename std::vector<T, Allocator>::reference type;
-};
-template<class T, class Allocator, class B> 
-struct plain_return_type_2<other_action<subscript_action>, const std::vector<T, Allocator>, B> { 
-  typedef typename std::vector<T, Allocator>::const_reference type;
-};
-
-  // basic_string
-template<class Char, class Traits, class Allocator, class B> 
-struct plain_return_type_2<other_action<subscript_action>, std::basic_string<Char, Traits, Allocator>, B> { 
-  typedef typename std::basic_string<Char, Traits, Allocator>::reference type;
-};
-template<class Char, class Traits, class Allocator, class B> 
-struct plain_return_type_2<other_action<subscript_action>, const std::basic_string<Char, Traits, Allocator>, B> { 
-  typedef typename std::basic_string<Char, Traits, Allocator>::const_reference type;
-};
-
-template<class Char, class Traits, class Allocator> 
-struct plain_return_type_2<arithmetic_action<plus_action>,
-                           std::basic_string<Char, Traits, Allocator>,
-                           std::basic_string<Char, Traits, Allocator> > { 
-  typedef std::basic_string<Char, Traits, Allocator> type;
-};
-
-template<class Char, class Traits, class Allocator> 
-struct plain_return_type_2<arithmetic_action<plus_action>,
-                           const Char*,
-                           std::basic_string<Char, Traits, Allocator> > { 
-  typedef std::basic_string<Char, Traits, Allocator> type;
-};
-
-template<class Char, class Traits, class Allocator> 
-struct plain_return_type_2<arithmetic_action<plus_action>,
-                           std::basic_string<Char, Traits, Allocator>,
-                           const Char*> { 
-  typedef std::basic_string<Char, Traits, Allocator> type;
-};
-
-template<class Char, class Traits, class Allocator, std::size_t N> 
-struct plain_return_type_2<arithmetic_action<plus_action>,
-                           Char[N],
-                           std::basic_string<Char, Traits, Allocator> > { 
-  typedef std::basic_string<Char, Traits, Allocator> type;
-};
-
-template<class Char, class Traits, class Allocator, std::size_t N> 
-struct plain_return_type_2<arithmetic_action<plus_action>,
-                           std::basic_string<Char, Traits, Allocator>,
-                           Char[N]> { 
-  typedef std::basic_string<Char, Traits, Allocator> type;
-};
-
-
-} // namespace lambda
-} // namespace boost
-
-#endif
-
-
diff --git a/contrib/restricted/boost/boost/lambda/detail/operators.hpp b/contrib/restricted/boost/boost/lambda/detail/operators.hpp
deleted file mode 100644
index 136e28f1b4..0000000000
--- a/contrib/restricted/boost/boost/lambda/detail/operators.hpp
+++ /dev/null
@@ -1,352 +0,0 @@
-// Boost Lambda Library - operators.hpp --------------------------------------
-
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//
-// Distributed under 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)
-//
-// For more information, see www.boost.org
-
-// ---------------------------------------------------------------
-
-#ifndef BOOST_LAMBDA_OPERATORS_HPP
-#define BOOST_LAMBDA_OPERATORS_HPP
-
-#include "boost/lambda/detail/is_instance_of.hpp"
-
-namespace boost { 
-namespace lambda {
-
-#if defined BOOST_LAMBDA_BE1
-#error "Multiple defines of BOOST_LAMBDA_BE1"
-#endif
-
-  // For all BOOSTA_LAMBDA_BE* macros:
-
-  // CONSTA must be either 'A' or 'const A'
-  // CONSTB must be either 'B' or 'const B'
-
-  // It is stupid to have the names A and B as macro arguments, but it avoids
-  // the need to pass in emtpy macro arguments, which gives warnings on some
-  // compilers
-
-#define BOOST_LAMBDA_BE1(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION)      \
-template<class Arg, class B>                                                 \
-inline const                                                                 \
-lambda_functor<                                                              \
-  lambda_functor_base<                                                       \
-    ACTION,                                                                  \
-    tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type>  \
-  >                                                                          \
->                                                                            \
-OPER_NAME (const lambda_functor<Arg>& a, CONSTB& b) {                      \
-  return                                                                     \
-    lambda_functor_base<                                                     \
-      ACTION,                                                                \
-      tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type>\
-    >                                                                        \
-   (tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type>(a, b)); \
-}
-
-
-#if defined BOOST_LAMBDA_BE2
-#error "Multiple defines of BOOST_LAMBDA_BE2"
-#endif
-
-#define BOOST_LAMBDA_BE2(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION)      \
-template<class A, class Arg>                                                 \
-inline const                                                                 \
-lambda_functor<                                                              \
-  lambda_functor_base<                                                       \
-    ACTION,                                                                  \
-    tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> >        \
-  >                                                                          \
->                                                                            \
-OPER_NAME (CONSTA& a, const lambda_functor<Arg>& b) {                      \
-  return                                                                     \
-    lambda_functor_base<                                                     \
-      ACTION,                                                                \
-      tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> >      \
-    >                                                                        \
-  (tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> >(a, b)); \
-}
-
-
-#if defined BOOST_LAMBDA_BE3
-#error "Multiple defines of BOOST_LAMBDA_BE3"
-#endif
-
-#define BOOST_LAMBDA_BE3(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION)    \
-template<class ArgA, class ArgB>                                           \
-inline const                                                               \
-lambda_functor<                                                            \
-  lambda_functor_base<                                                     \
-    ACTION,                                                                \
-    tuple<lambda_functor<ArgA>, lambda_functor<ArgB> >                     \
-  >                                                                        \
->                                                                          \
-OPER_NAME (const lambda_functor<ArgA>& a, const lambda_functor<ArgB>& b) { \
-  return                                                                   \
-    lambda_functor_base<                                                   \
-      ACTION,                                                              \
-      tuple<lambda_functor<ArgA>, lambda_functor<ArgB> >                   \
-    >                                                                      \
-  (tuple<lambda_functor<ArgA>, lambda_functor<ArgB> >(a, b));              \
-}
-
-#if defined BOOST_LAMBDA_BE
-#error "Multiple defines of BOOST_LAMBDA_BE"
-#endif
-
-#define BOOST_LAMBDA_BE(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION) \
-BOOST_LAMBDA_BE1(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION)        \
-BOOST_LAMBDA_BE2(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION)        \
-BOOST_LAMBDA_BE3(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION)
-
-#define BOOST_LAMBDA_EMPTY() 
-
-BOOST_LAMBDA_BE(operator+, arithmetic_action<plus_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator-, arithmetic_action<minus_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator*, arithmetic_action<multiply_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator/, arithmetic_action<divide_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator%, arithmetic_action<remainder_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator<<, bitwise_action<leftshift_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator>>, bitwise_action<rightshift_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator&, bitwise_action<and_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator|, bitwise_action<or_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator^, bitwise_action<xor_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator&&, logical_action<and_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator||, logical_action<or_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator<, relational_action<less_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator>, relational_action<greater_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator<=, relational_action<lessorequal_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator>=, relational_action<greaterorequal_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator==, relational_action<equal_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator!=, relational_action<notequal_action>, const A, const B, const_copy_argument)
-
-BOOST_LAMBDA_BE(operator+=, arithmetic_assignment_action<plus_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator-=, arithmetic_assignment_action<minus_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator*=, arithmetic_assignment_action<multiply_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator/=, arithmetic_assignment_action<divide_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator%=, arithmetic_assignment_action<remainder_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator<<=, bitwise_assignment_action<leftshift_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator>>=, bitwise_assignment_action<rightshift_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator&=, bitwise_assignment_action<and_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator|=, bitwise_assignment_action<or_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator^=, bitwise_assignment_action<xor_action>, A, const B, reference_argument)
-
-
-// A special trick for comma operator for correct preprocessing
-#if defined BOOST_LAMBDA_COMMA_OPERATOR_NAME
-#error "Multiple defines of BOOST_LAMBDA_COMMA_OPERATOR_NAME"
-#endif
-
-#define BOOST_LAMBDA_COMMA_OPERATOR_NAME operator,
-
-BOOST_LAMBDA_BE1(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE2(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE3(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
-
-
-
-namespace detail {
-
-// special cases for ostream& << Any and istream& >> Any ---------------
-// the actual stream classes may vary and thus a specialisation for, 
-// say ostream& does not match (the general case above is chosen). 
-// Therefore we specialise for non-const reference:
-// if the left argument is a stream, we store the stream as reference
-// if it is something else, we store a const plain by default
-
-// Note that the overloading is const vs. non-const first argument
-
-
-template<class T> struct convert_ostream_to_ref_others_to_c_plain_by_default {
-  typedef typename detail::IF<
-                       is_instance_of_2<
-                         T, std::basic_ostream
-                       >::value,
-                       T&,
-                       typename const_copy_argument <T>::type
-                     >::RET type;
-};
-
-template<class T> struct convert_istream_to_ref_others_to_c_plain_by_default {
-  typedef typename detail::IF<
-                       is_instance_of_2<
-                         T, std::basic_istream
-                       >::value,
-                       T&,
-                       typename const_copy_argument <T>::type
-                     >::RET type;
-};
-
-} // detail
-
-BOOST_LAMBDA_BE2(operator<<, bitwise_action< leftshift_action>, A, const B, detail::convert_ostream_to_ref_others_to_c_plain_by_default)
-BOOST_LAMBDA_BE2(operator>>, bitwise_action< rightshift_action>, A, const B, detail::convert_istream_to_ref_others_to_c_plain_by_default)      
-
-
-// special case for io_manipulators.
-// function references cannot be given as arguments to lambda operator
-// expressions in general. With << and >> the use of manipulators is
-// so common, that specializations are provided to make them work.
-
-template<class Arg, class Ret, class ManipArg>
-inline const 
-lambda_functor<
-  lambda_functor_base<
-    bitwise_action<leftshift_action>,
-    tuple<lambda_functor<Arg>, Ret(&)(ManipArg)> 
-  > 
->
-operator<<(const lambda_functor<Arg>& a, Ret(&b)(ManipArg))
-{
-  return 
-      lambda_functor_base<
-        bitwise_action<leftshift_action>,
-        tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>
-      > 
-    ( tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>(a, b) );
-}
-
-template<class Arg, class Ret, class ManipArg>
-inline const 
-lambda_functor<
-  lambda_functor_base<
-    bitwise_action<rightshift_action>,
-    tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>
-  > 
->
-operator>>(const lambda_functor<Arg>& a, Ret(&b)(ManipArg))
-{
-  return 
-      lambda_functor_base<
-        bitwise_action<rightshift_action>,
-        tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>
-      > 
-    ( tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>(a, b) );
-}
-
-
-// (+ and -) take their arguments as const references. 
-// This has consquences with pointer artihmetic
-// E.g int a[]; ... *a = 1 works but not *(a+1) = 1. 
-// the result of a+1 would be const
-// To make the latter work too, 
-// non-const arrays are taken as non-const and stored as non-const as well.
-#if defined  BOOST_LAMBDA_PTR_ARITHMETIC_E1
-#error "Multiple defines of  BOOST_LAMBDA_PTR_ARITHMETIC_E1"
-#endif
-
-#define BOOST_LAMBDA_PTR_ARITHMETIC_E1(OPER_NAME, ACTION, CONSTB)           \
-template<class Arg, int N, class B>                                         \
-inline const                                                                \
-lambda_functor<                                                             \
-  lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONSTB(&)[N]> >    \
->                                                                           \
-OPER_NAME (const lambda_functor<Arg>& a, CONSTB(&b)[N])                     \
-{                                                                           \
-  return                                                                    \
-    lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONSTB(&)[N]> >  \
-  (tuple<lambda_functor<Arg>, CONSTB(&)[N]>(a, b));                         \
-}
-
-
-#if defined  BOOST_LAMBDA_PTR_ARITHMETIC_E2
-#error "Multiple defines of  BOOST_LAMBDA_PTR_ARITHMETIC_E2"
-#endif
-
-#define BOOST_LAMBDA_PTR_ARITHMETIC_E2(OPER_NAME, ACTION, CONSTA)           \
-template<int N, class A, class Arg>                                         \
-inline const                                                                \
-lambda_functor<                                                             \
-  lambda_functor_base<ACTION, tuple<CONSTA(&)[N], lambda_functor<Arg> > >   \
->                                                                           \
-OPER_NAME (CONSTA(&a)[N], const lambda_functor<Arg>& b)                     \
-{                                                                           \
-  return                                                                    \
-    lambda_functor_base<ACTION, tuple<CONSTA(&)[N], lambda_functor<Arg> > > \
-    (tuple<CONSTA(&)[N], lambda_functor<Arg> >(a, b));                      \
-}
-
-
-BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator+, arithmetic_action<plus_action>, B)
-BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator+, arithmetic_action<plus_action>, A)
-BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator+, arithmetic_action<plus_action>,const B)
-BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator+, arithmetic_action<plus_action>,const A)
-
-
-//BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator-, arithmetic_action<minus_action>)
-// This is not needed, since the result of ptr-ptr is an rvalue anyway
-
-BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator-, arithmetic_action<minus_action>, A)
-BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator-, arithmetic_action<minus_action>, const A)
-
-
-#undef BOOST_LAMBDA_BE1
-#undef BOOST_LAMBDA_BE2
-#undef BOOST_LAMBDA_BE3
-#undef BOOST_LAMBDA_BE
-#undef BOOST_LAMBDA_COMMA_OPERATOR_NAME
-
-#undef BOOST_LAMBDA_PTR_ARITHMETIC_E1
-#undef BOOST_LAMBDA_PTR_ARITHMETIC_E2
-
-
-// ---------------------------------------------------------------------
-// unary operators -----------------------------------------------------
-// ---------------------------------------------------------------------
-
-#if defined BOOST_LAMBDA_UE
-#error "Multiple defines of BOOST_LAMBDA_UE"
-#endif
-
-#define BOOST_LAMBDA_UE(OPER_NAME, ACTION)                                 \
-template<class Arg>                                                        \
-inline const                                                               \
-lambda_functor<lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > > > \
-OPER_NAME (const lambda_functor<Arg>& a)                                   \
-{                                                                          \
-  return                                                                   \
-    lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > >              \
-    ( tuple<lambda_functor<Arg> >(a) );                                    \
-}
-
-
-BOOST_LAMBDA_UE(operator+, unary_arithmetic_action<plus_action>)
-BOOST_LAMBDA_UE(operator-, unary_arithmetic_action<minus_action>)
-BOOST_LAMBDA_UE(operator~, bitwise_action<not_action>)
-BOOST_LAMBDA_UE(operator!, logical_action<not_action>)
-BOOST_LAMBDA_UE(operator++, pre_increment_decrement_action<increment_action>)
-BOOST_LAMBDA_UE(operator--, pre_increment_decrement_action<decrement_action>)
-BOOST_LAMBDA_UE(operator*, other_action<contentsof_action>)
-BOOST_LAMBDA_UE(operator&, other_action<addressof_action>)
-
-#if defined BOOST_LAMBDA_POSTFIX_UE
-#error "Multiple defines of BOOST_LAMBDA_POSTFIX_UE"
-#endif
-
-#define BOOST_LAMBDA_POSTFIX_UE(OPER_NAME, ACTION)                         \
-template<class Arg>                                                        \
-inline const                                                               \
-lambda_functor<lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > > > \
-OPER_NAME (const lambda_functor<Arg>& a, int)                              \
-{                                                                          \
-  return                                                                   \
-    lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > >              \
-    ( tuple<lambda_functor<Arg> >(a) );                                    \
-}
-
-
-BOOST_LAMBDA_POSTFIX_UE(operator++, post_increment_decrement_action<increment_action>)
-BOOST_LAMBDA_POSTFIX_UE(operator--, post_increment_decrement_action<decrement_action>)
-
-#undef BOOST_LAMBDA_UE
-#undef BOOST_LAMBDA_POSTFIX_UE
-
-} // namespace lambda
-} // namespace boost
-
-#endif
diff --git a/contrib/restricted/boost/boost/lambda/detail/ret.hpp b/contrib/restricted/boost/boost/lambda/detail/ret.hpp
deleted file mode 100644
index 96f5fc18bb..0000000000
--- a/contrib/restricted/boost/boost/lambda/detail/ret.hpp
+++ /dev/null
@@ -1,325 +0,0 @@
-// Boost Lambda Library  ret.hpp -----------------------------------------
-
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//
-// Distributed under 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)
-//
-// For more information, see www.boost.org
-
-
-#ifndef BOOST_LAMBDA_RET_HPP
-#define BOOST_LAMBDA_RET_HPP
-
-namespace boost { 
-namespace lambda {
-
-  // TODO:
-
-//  Add specializations for function references for ret, protect and unlambda
-//  e.g void foo(); unlambda(foo); fails, as it would add a const qualifier
-  // for a function type. 
-  // on the other hand unlambda(*foo) does work
-
-
-// -- ret -------------------------
-// the explicit return type template 
-
-  // TODO: It'd be nice to make ret a nop for other than lambda functors
-  // but causes an ambiguiyty with gcc (not with KCC), check what is the
-  // right interpretation.
-
-  //  // ret for others than lambda functors has no effect
-  // template <class U, class T>
-  // inline const T& ret(const T& t) { return t; }
-
-
-template<class RET, class Arg>
-inline const 
-lambda_functor<
-  lambda_functor_base<
-    explicit_return_type_action<RET>, 
-    tuple<lambda_functor<Arg> >
-  > 
->
-ret(const lambda_functor<Arg>& a1)
-{
-  return  
-    lambda_functor_base<
-      explicit_return_type_action<RET>, 
-      tuple<lambda_functor<Arg> >
-    > 
-    (tuple<lambda_functor<Arg> >(a1));
-}
-
-// protect ------------------
-
-  // protecting others than lambda functors has no effect
-template <class T>
-inline const T& protect(const T& t) { return t; }
-
-template<class Arg>
-inline const 
-lambda_functor<
-  lambda_functor_base<
-    protect_action, 
-    tuple<lambda_functor<Arg> >
-  > 
->
-protect(const lambda_functor<Arg>& a1)
-{
-  return 
-      lambda_functor_base<
-        protect_action, 
-        tuple<lambda_functor<Arg> >
-      > 
-    (tuple<lambda_functor<Arg> >(a1));
-}
-   
-// -------------------------------------------------------------------
-
-// Hides the lambda functorness of a lambda functor. 
-// After this, the functor is immune to argument substitution, etc.
-// This can be used, e.g. to make it safe to pass lambda functors as 
-// arguments to functions, which might use them as target functions
-
-// note, unlambda and protect are different things. Protect hides the lambda
-// functor for one application, unlambda for good.
-
-template <class LambdaFunctor>
-class non_lambda_functor
-{
-  LambdaFunctor lf;
-public:
-  
-  // This functor defines the result_type typedef.
-  // The result type must be deducible without knowing the arguments
-
-  template <class SigArgs> struct sig {
-    typedef typename 
-      LambdaFunctor::inherited:: 
-        template sig<typename SigArgs::tail_type>::type type;
-  };
-
-  explicit non_lambda_functor(const LambdaFunctor& a) : lf(a) {}
-
-  typename LambdaFunctor::nullary_return_type  
-  operator()() const {
-    return lf.template 
-      call<typename LambdaFunctor::nullary_return_type>
-        (cnull_type(), cnull_type(), cnull_type(), cnull_type()); 
-  }
-
-  template<class A>
-  typename sig<tuple<const non_lambda_functor, A&> >::type 
-  operator()(A& a) const {
-    return lf.template call<typename sig<tuple<const non_lambda_functor, A&> >::type >(a, cnull_type(), cnull_type(), cnull_type()); 
-  }
-
-  template<class A, class B>
-  typename sig<tuple<const non_lambda_functor, A&, B&> >::type 
-  operator()(A& a, B& b) const {
-    return lf.template call<typename sig<tuple<const non_lambda_functor, A&, B&> >::type >(a, b, cnull_type(), cnull_type()); 
-  }
-
-  template<class A, class B, class C>
-  typename sig<tuple<const non_lambda_functor, A&, B&, C&> >::type 
-  operator()(A& a, B& b, C& c) const {
-    return lf.template call<typename sig<tuple<const non_lambda_functor, A&, B&, C&> >::type>(a, b, c, cnull_type()); 
-  }
-};
-
-template <class Arg>
-inline const Arg& unlambda(const Arg& a) { return a; }
-
-template <class Arg>
-inline const non_lambda_functor<lambda_functor<Arg> > 
-unlambda(const lambda_functor<Arg>& a)
-{
-  return non_lambda_functor<lambda_functor<Arg> >(a);
-}
-
-  // Due to a language restriction, lambda functors cannot be made to
-  // accept non-const rvalue arguments. Usually iterators do not return 
-  // temporaries, but sometimes they do. That's why a workaround is provided.
-  // Note, that this potentially breaks const correctness, so be careful!
-
-// any lambda functor can be turned into a const_incorrect_lambda_functor
-// The operator() takes arguments as consts and then casts constness
-// away. So this breaks const correctness!!! but is a necessary workaround
-// in some cases due to language limitations.
-// Note, that this is not a lambda_functor anymore, so it can not be used
-// as a sub lambda expression.
-
-template <class LambdaFunctor>
-struct const_incorrect_lambda_functor {
-  LambdaFunctor lf;
-public:
-
-  explicit const_incorrect_lambda_functor(const LambdaFunctor& a) : lf(a) {}
-
-  template <class SigArgs> struct sig {
-    typedef typename
-      LambdaFunctor::inherited::template 
-        sig<typename SigArgs::tail_type>::type type;
-  };
-
-  // The nullary case is not needed (no arguments, no parameter type problems)
-
-  template<class A>
-  typename sig<tuple<const const_incorrect_lambda_functor, A&> >::type
-  operator()(const A& a) const {
-    return lf.template call<typename sig<tuple<const const_incorrect_lambda_functor, A&> >::type >(const_cast<A&>(a), cnull_type(), cnull_type(), cnull_type());
-  }
-
-  template<class A, class B>
-  typename sig<tuple<const const_incorrect_lambda_functor, A&, B&> >::type
-  operator()(const A& a, const B& b) const {
-    return lf.template call<typename sig<tuple<const const_incorrect_lambda_functor, A&, B&> >::type >(const_cast<A&>(a), const_cast<B&>(b), cnull_type(), cnull_type());
-  }
-
-  template<class A, class B, class C>
-  typename sig<tuple<const const_incorrect_lambda_functor, A&, B&, C&> >::type
-  operator()(const A& a, const B& b, const C& c) const {
-    return lf.template call<typename sig<tuple<const const_incorrect_lambda_functor, A&, B&, C&> >::type>(const_cast<A&>(a), const_cast<B&>(b), const_cast<C&>(c), cnull_type());
-  }
-};
-
-// ------------------------------------------------------------------------
-// any lambda functor can be turned into a const_parameter_lambda_functor
-// The operator() takes arguments as const.
-// This is useful if lambda functors are called with non-const rvalues.
-// Note, that this is not a lambda_functor anymore, so it can not be used
-// as a sub lambda expression.
-
-template <class LambdaFunctor>
-struct const_parameter_lambda_functor {
-  LambdaFunctor lf;
-public:
-
-  explicit const_parameter_lambda_functor(const LambdaFunctor& a) : lf(a) {}
-
-  template <class SigArgs> struct sig {
-    typedef typename
-      LambdaFunctor::inherited::template 
-        sig<typename SigArgs::tail_type>::type type;
-  };
-
-  // The nullary case is not needed: no arguments, no constness problems.
-
-  template<class A>
-  typename sig<tuple<const const_parameter_lambda_functor, const A&> >::type
-  operator()(const A& a) const {
-    return lf.template call<typename sig<tuple<const const_parameter_lambda_functor, const A&> >::type >(a, cnull_type(), cnull_type(), cnull_type());
-  }
-
-  template<class A, class B>
-  typename sig<tuple<const const_parameter_lambda_functor, const A&, const B&> >::type
-  operator()(const A& a, const B& b) const {
-    return lf.template call<typename sig<tuple<const const_parameter_lambda_functor, const A&, const B&> >::type >(a, b, cnull_type(), cnull_type());
-  }
-
-  template<class A, class B, class C>
-  typename sig<tuple<const const_parameter_lambda_functor, const A&, const B&, const C&>
->::type
-  operator()(const A& a, const B& b, const C& c) const {
-    return lf.template call<typename sig<tuple<const const_parameter_lambda_functor, const A&, const B&, const C&> >::type>(a, b, c, cnull_type());
-  }
-};
-
-template <class Arg>
-inline const const_incorrect_lambda_functor<lambda_functor<Arg> >
-break_const(const lambda_functor<Arg>& lf)
-{
-  return const_incorrect_lambda_functor<lambda_functor<Arg> >(lf);
-}
-
-
-template <class Arg>
-inline const const_parameter_lambda_functor<lambda_functor<Arg> >
-const_parameters(const lambda_functor<Arg>& lf)
-{
-  return const_parameter_lambda_functor<lambda_functor<Arg> >(lf);
-}
-
-// make void ------------------------------------------------
-// make_void( x ) turns a lambda functor x with some return type y into
-// another lambda functor, which has a void return type
-// when called, the original return type is discarded
-
-// we use this action. The action class will be called, which means that
-// the wrapped lambda functor is evaluated, but we just don't do anything
-// with the result.
-struct voidifier_action {
-  template<class Ret, class A> static void apply(A&) {}
-};
-
-template<class Args> struct return_type_N<voidifier_action, Args> {
-  typedef void type;
-};
-
-template<class Arg1>
-inline const 
-lambda_functor<
-  lambda_functor_base<
-    action<1, voidifier_action>,
-    tuple<lambda_functor<Arg1> >
-  > 
-> 
-make_void(const lambda_functor<Arg1>& a1) { 
-return 
-    lambda_functor_base<
-      action<1, voidifier_action>,
-      tuple<lambda_functor<Arg1> >
-    > 
-  (tuple<lambda_functor<Arg1> > (a1));
-}
-
-// for non-lambda functors, make_void does nothing 
-// (the argument gets evaluated immediately)
-
-template<class Arg1>
-inline const 
-lambda_functor<
-  lambda_functor_base<do_nothing_action, null_type> 
-> 
-make_void(const Arg1&) { 
-return 
-    lambda_functor_base<do_nothing_action, null_type>();
-}
-
-// std_functor -----------------------------------------------------
-
-//  The STL uses the result_type typedef as the convention to let binders know
-//  the return type of a function object. 
-//  LL uses the sig template.
-//  To let LL know that the function object has the result_type typedef 
-//  defined, it can be wrapped with the std_functor function.
-
-
-// Just inherit form the template parameter (the standard functor), 
-// and provide a sig template. So we have a class which is still the
-// same functor + the sig template.
-
-template<class T>
-struct result_type_to_sig : public T {
-  template<class Args> struct sig { typedef typename T::result_type type; };
-  result_type_to_sig(const T& t) : T(t) {}
-};
-
-template<class F>
-inline result_type_to_sig<F> std_functor(const F& f) { return f; }
-
-
-} // namespace lambda 
-} // namespace boost
-
-#endif
-
-
-
-
-
-
-
diff --git a/contrib/restricted/boost/boost/lambda/detail/return_type_traits.hpp b/contrib/restricted/boost/boost/lambda/detail/return_type_traits.hpp
deleted file mode 100644
index da2879cbb0..0000000000
--- a/contrib/restricted/boost/boost/lambda/detail/return_type_traits.hpp
+++ /dev/null
@@ -1,269 +0,0 @@
-//  return_type_traits.hpp -- Boost Lambda Library ---------------------------
-
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//
-// Distributed under 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)
-//
-// For more information, see www.boost.org
-
-
-#ifndef BOOST_LAMBDA_RETURN_TYPE_TRAITS_HPP
-#define BOOST_LAMBDA_RETURN_TYPE_TRAITS_HPP
-
-#include "boost/mpl/has_xxx.hpp"
-
-#include <cstddef> // needed for the ptrdiff_t
-
-namespace boost { 
-namespace lambda {
-
-// Much of the type deduction code for standard arithmetic types 
-// from Gary Powell
-
-  // different arities:
-template <class Act, class A1> struct return_type_1; // 1-ary actions
-template <class Act, class A1, class A2> struct return_type_2; // 2-ary
-template <class Act, class Args> struct return_type_N; // >3- ary
-
-template <class Act, class A1> struct return_type_1_prot;
-template <class Act, class A1, class A2> struct return_type_2_prot; // 2-ary
-template <class Act, class A1> struct return_type_N_prot; // >3-ary
-
-
-namespace detail {
-
-template<class> class return_type_deduction_failure {};
-
-  // In some cases return type deduction should fail (an invalid lambda 
-  // expression). Sometimes the lambda expression can be ok, the return type
-  // just is not deducible (user defined operators). Then return type deduction
-  // should never be entered at all, and the use of ret<> does this.
-  // However, for nullary lambda functors, return type deduction is always
-  // entered, and there seems to be no way around this.
-
-  // (the return type is part of the prototype of the non-template
-  // operator()(). The prototype is instantiated, even though the body 
-  // is not.) 
- 
-  // So, in the case the return type deduction should fail, it should not
-  // fail directly, but rather result in a valid but wrong return type,
-  // causing a compile time error only if the function is really called.
-
-
-
-} // end detail
-
-
-
-// return_type_X_prot classes --------------------------------------------
-// These classes are the first layer that gets instantiated from the 
-// lambda_functor_base sig templates. It will check whether 
-// the action is protectable and one of arguments is "protected" or its
-// evaluation will otherwise result in another lambda functor.
-// If this is a case, the result type will be another lambda functor.
-
-// The arguments are always non-reference types, except for comma action
-// where the right argument can be a reference too. This is because it 
-// matters (in the builtin case) whether the argument is an lvalue or 
-// rvalue: int i; i, 1 -> rvalue; 1, i -> lvalue
-
-template <class Act, class A> struct return_type_1_prot {
-public:
-  typedef typename 
-    detail::IF<
-      is_protectable<Act>::value && is_lambda_functor<A>::value,
-      lambda_functor<
-        lambda_functor_base< 
-          Act, 
-          tuple<typename detail::remove_reference_and_cv<A>::type>
-        >
-      >,
-      typename return_type_1<Act, A>::type
-    >::RET type;  
-};
-
-  // take care of the unavoidable instantiation for nullary case
-template<class Act> struct return_type_1_prot<Act, null_type> {
-  typedef null_type type;
-};
- 
-// Unary actions (result from unary operators)
-// do not have a default return type.
-template<class Act, class A> struct return_type_1 { 
-   typedef typename 
-     detail::return_type_deduction_failure<return_type_1> type;
-};
-
-
-namespace detail {
-
-  template <class T>
-  class protect_conversion {
-      typedef typename boost::remove_reference<T>::type non_ref_T;
-    public:
-
-  // add const to rvalues, so that all rvalues are stored as const in 
-  // the args tuple
-    typedef typename detail::IF_type<
-      boost::is_reference<T>::value && !boost::is_const<non_ref_T>::value,
-      detail::identity_mapping<T>,
-      const_copy_argument<non_ref_T> // handles funtion and array 
-    >::type type;                      // types correctly
-  };
-
-} // end detail
-
-template <class Act, class A, class B> struct return_type_2_prot {
-
-// experimental feature
-  // We may have a lambda functor as a result type of a subexpression 
-  // (if protect) has  been used.
-  // Thus, if one of the parameter types is a lambda functor, the result
-  // is a lambda functor as well. 
-  // We need to make a conservative choise here.
-  // The resulting lambda functor stores all const reference arguments as
-  // const copies. References to non-const are stored as such.
-  // So if the source of the argument is a const open argument, a bound
-  // argument stored as a const reference, or a function returning a 
-  // const reference, that information is lost. There is no way of 
-  // telling apart 'real const references' from just 'LL internal
-  // const references' (or it would be really hard)
-
-  // The return type is a subclass of lambda_functor, which has a converting 
-  // copy constructor. It can copy any lambda functor, that has the same 
-  // action type and code, and a copy compatible argument tuple.
-
-
-  typedef typename boost::remove_reference<A>::type non_ref_A;
-  typedef typename boost::remove_reference<B>::type non_ref_B;
-
-typedef typename 
-  detail::IF<
-    is_protectable<Act>::value &&
-      (is_lambda_functor<A>::value || is_lambda_functor<B>::value),
-    lambda_functor<
-      lambda_functor_base< 
-        Act, 
-        tuple<typename detail::protect_conversion<A>::type, 
-              typename detail::protect_conversion<B>::type>
-      >
-    >,
-    typename return_type_2<Act, non_ref_A, non_ref_B>::type
-  >::RET type;
-};
-
-  // take care of the unavoidable instantiation for nullary case
-template<class Act> struct return_type_2_prot<Act, null_type, null_type> {
-  typedef null_type type;
-};
-  // take care of the unavoidable instantiation for nullary case
-template<class Act, class Other> struct return_type_2_prot<Act, Other, null_type> {
-  typedef null_type type;
-};
-  // take care of the unavoidable instantiation for nullary case
-template<class Act, class Other> struct return_type_2_prot<Act, null_type, Other> {
-  typedef null_type type;
-};
-
-  // comma is a special case, as the user defined operator can return
-  // an lvalue (reference) too, hence it must be handled at this level.
-template<class A, class B> 
-struct return_type_2_comma
-{
-  typedef typename boost::remove_reference<A>::type non_ref_A;
-  typedef typename boost::remove_reference<B>::type non_ref_B;
-
-typedef typename 
-  detail::IF<
-    is_protectable<other_action<comma_action> >::value && // it is protectable
-    (is_lambda_functor<A>::value || is_lambda_functor<B>::value),
-    lambda_functor<
-      lambda_functor_base< 
-        other_action<comma_action>, 
-        tuple<typename detail::protect_conversion<A>::type, 
-              typename detail::protect_conversion<B>::type>
-      >
-    >,
-    typename 
-      return_type_2<other_action<comma_action>, non_ref_A, non_ref_B>::type
-  >::RET type1;
-
-   // if no user defined return_type_2 (or plain_return_type_2) specialization
-  // matches, then return the righthand argument
-  typedef typename 
-    detail::IF<
-      boost::is_same<type1, detail::unspecified>::value, 
-      B,
-      type1
-    >::RET type;
-
-};
-
-
-  // currently there are no protectable actions with > 2 args
-
-template<class Act, class Args> struct return_type_N_prot {
-  typedef typename return_type_N<Act, Args>::type type;
-};
-
-  // take care of the unavoidable instantiation for nullary case
-template<class Act> struct return_type_N_prot<Act, null_type> {
-  typedef null_type type;
-};
-
-// handle different kind of actions ------------------------
-
-  // use the return type given in the bind invocation as bind<Ret>(...)
-template<int I, class Args, class Ret> 
-struct return_type_N<function_action<I, Ret>, Args> { 
-  typedef Ret type;
-};
-
-// ::result_type support
-
-namespace detail
-{
-
-BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type)
-
-template<class F> struct get_result_type
-{
-  typedef typename F::result_type type;
-};
-
-template<class F, class A> struct get_sig
-{
-  typedef typename function_adaptor<F>::template sig<A>::type type;
-};
-
-} // namespace detail
-
-  // Ret is detail::unspecified, so try to deduce return type
-template<int I, class Args> 
-struct return_type_N<function_action<I, detail::unspecified>, Args > { 
-
-  // in the case of function action, the first element in Args is 
-  // some type of function
-  typedef typename Args::head_type Func;
-  typedef typename detail::remove_reference_and_cv<Func>::type plain_Func;
-
-public: 
-  // pass the function to function_adaptor, and get the return type from 
-  // that
-  typedef typename detail::IF<
-    detail::has_result_type<plain_Func>::value,
-    detail::get_result_type<plain_Func>,
-    detail::get_sig<plain_Func, Args>
-  >::RET::type type;
-};
-
-
-} // namespace lambda
-} // namespace boost
-
-#endif
-
-
-
diff --git a/contrib/restricted/boost/boost/lambda/detail/select_functions.hpp b/contrib/restricted/boost/boost/lambda/detail/select_functions.hpp
deleted file mode 100644
index 956045c63f..0000000000
--- a/contrib/restricted/boost/boost/lambda/detail/select_functions.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-// -- select_functions.hpp -- Boost Lambda Library --------------------------
-
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//
-// Distributed under 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)
-//
-// For more information, see http://www.boost.org
-
-
-#ifndef BOOST_LAMBDA_SELECT_FUNCTIONS_HPP
-#define BOOST_LAMBDA_SELECT_FUNCTIONS_HPP
-
-namespace boost { 
-namespace lambda {
-namespace detail {
-
-
-// select functions -------------------------------
-template<class Any, CALL_TEMPLATE_ARGS>
-inline Any& select(Any& any, CALL_FORMAL_ARGS) { CALL_USE_ARGS; return any; }
-
-
-template<class Arg, CALL_TEMPLATE_ARGS>
-inline typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
-select ( const lambda_functor<Arg>& op, CALL_FORMAL_ARGS ) { 
-  return op.template call<
-    typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
-  >(CALL_ACTUAL_ARGS); 
-}
-template<class Arg, CALL_TEMPLATE_ARGS>
-inline typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
-select ( lambda_functor<Arg>& op, CALL_FORMAL_ARGS) { 
-  return op.template call<
-    typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
-  >(CALL_ACTUAL_ARGS); 
-}
-
-// ------------------------------------------------------------------------
-// select functions where the return type is explicitly given
-// Note: on many functions, this return type is just discarded.
-// The select functions are inside a class template, and the return type
-// is a class template argument.
-// The first implementation used function templates with an explicitly 
-// specified template parameter.
-// However, this resulted in ambiguous calls (at least with gcc 2.95.2 
-// and edg 2.44). Not sure whether the compilers were right or wrong. 
-  
-template<class RET> struct r_select {
-
-// Any == RET
-  template<class Any, CALL_TEMPLATE_ARGS>
-  static 
-  inline RET go (Any& any, CALL_FORMAL_ARGS) { CALL_USE_ARGS; return any; }
-
-
-  template<class Arg, CALL_TEMPLATE_ARGS> 
-  static 
-  inline RET go (const lambda_functor<Arg>& op, CALL_FORMAL_ARGS ) {
-    return op.template call<RET>(CALL_ACTUAL_ARGS); 
-  }
-  template<class Arg, CALL_TEMPLATE_ARGS> 
-  static 
-  inline RET go (lambda_functor<Arg>& op, CALL_FORMAL_ARGS ) { 
-    return op.template call<RET>(CALL_ACTUAL_ARGS); 
-  }
-};
-   
-} // namespace detail
-} // namespace lambda
-} // namespace boost
-
-#endif
diff --git a/contrib/restricted/boost/boost/lambda/detail/suppress_unused.hpp b/contrib/restricted/boost/boost/lambda/detail/suppress_unused.hpp
deleted file mode 100644
index 5dd339d01b..0000000000
--- a/contrib/restricted/boost/boost/lambda/detail/suppress_unused.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-// Boost Lambda Library  suppress_unused.hpp -----------------------------
-//
-// Copyright (C) 2009 Steven Watanabe
-//
-// Distributed under 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)
-//
-// For more information, see www.boost.org
-
-// ------------------------------------------------------------
-
-#ifndef BOOST_LAMBDA_SUPPRESS_UNUSED_HPP
-#define BOOST_LAMBDA_SUPPRESS_UNUSED_HPP
-
-namespace boost { 
-namespace lambda {
-namespace detail {
-
-template<class T>
-inline void suppress_unused_variable_warnings(const T&) {}
-
-}
-}
-}
-
-#endif
diff --git a/contrib/restricted/boost/boost/lambda/exceptions.hpp b/contrib/restricted/boost/boost/lambda/exceptions.hpp
deleted file mode 100644
index 4f7e8954a3..0000000000
--- a/contrib/restricted/boost/boost/lambda/exceptions.hpp
+++ /dev/null
@@ -1,1741 +0,0 @@
-// -- Boost Lambda Library -- exceptions.hpp ----------------
-//
-// Copyright (C) 2000 Gary Powell (gwpowell@hotmail.com)
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//
-// Distributed under 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)
-//
-// For more information, see http://www.boost.org 
-
-// -----------------------------------------------------
-
-#if !defined(BOOST_LAMBDA_EXCEPTIONS_HPP)
-#define BOOST_LAMBDA_EXCEPTIONS_HPP
-
-#include "boost/lambda/core.hpp"
-#include "boost/lambda/detail/control_constructs_common.hpp"
-
-namespace boost { 
-namespace lambda {
-
-typedef lambda_functor<placeholder<EXCEPTION> > placeholderE_type;
-
-namespace {
-  boost::lambda::placeholderE_type freeE;
-  boost::lambda::placeholderE_type& _e = freeE;        
-}
-
-// -- exception related actions -------------------
-
-// catch actions.
-template <class Catch1, class Catch2 = null_type, class Catch3 = null_type, 
-          class Catch4 = null_type, class Catch5 = null_type, 
-          class Catch6 = null_type, class Catch7 = null_type, 
-          class Catch8 = null_type, class Catch9 = null_type, 
-          class Catch10 = null_type>
-struct catch_action {};
-
-struct catch_all_action {};
-
-template<class CatchActions>
-struct return_try_catch_action {};
-
-template<class CatchActions>
-struct try_catch_action {};
-
-// rethrow actions
-struct throw_new_action {};
-struct rethrow_action {};
-
-template<class ThrowType> struct throw_action;
-
-template<>
-struct throw_action<rethrow_action> {
-  template<class RET>
-  static RET apply() {
-    throw;
-  }
-};
-
-template<> struct throw_action<throw_new_action> {
-  template<class RET, class T>
-  static RET apply(T& t) {
-    throw t;
-  }
-};
-
-// return types for throw_actions --------------------------------------------
-
-template<class T, class Any>
-struct 
-return_type_N<throw_action<T>, Any> {
-  typedef void type;
-};
-
-
-// return types deductions -------------------------------------------------
-
-// the return type of try_catch is the return type of the try lambda_functor
-// (the return types of try and catch parts must match unless try returns void
-// or the catch part throws for sure)
-
-// NOTE, the exception placeholder deduction rule is defined 
-// in return_type_traits.hpp
-
-
-
-// defined in control_constructs
-class ifthenelse_action;
-
-namespace detail {
-
-// Templates for deducing, wether a lambda_functor throws inevitably of not -
-// This mechanism is needed to make the compiler happy about
-// return types of try and catch parts. 
-
-// a lambda_functor throws for sure if:
-//  - it is a throw expression
-//  - it is a comma expression, and one of its arguments throws for sure
-//  - it is an if_then_else expression and either the if statement or both 
-//  the then and  else throw.
-// (there are other cases as well, but we do not cover them)
-// e.g. _1 + (rethrow(), 3) does throw for sure but this is not checked
-// This implies, that in such a case, the return types of try and catch parts 
-// must match if the try part returns other than void.
-// (Such checks could be done though)
-
-template <class Arg> 
-struct throws_for_sure_phase2 {
-  static const bool value = false;
-};
-
-template <int N, class ThrowType, class Args> 
-struct throws_for_sure_phase2<
-  lambda_functor< 
-    lambda_functor_base<action<N, throw_action<ThrowType> >, Args> 
-  > 
->
-{
-  static const bool value = true;
-};
-
-// Both then and else or the if throw of an if_then_else.
-template <class Args> 
-struct throws_for_sure_phase2<
-  lambda_functor<
-    lambda_functor_base<
-      ifthenelse_action, Args
-    > 
-  > 
->
-{
-  static const bool value =
-    throws_for_sure_phase2<
-      typename boost::tuples::element<0, Args>::type>::value
-    ||  
-    (
-       throws_for_sure_phase2<
-         typename boost::tuples::element<1, Args>::type
-       >::value
-       && 
-       throws_for_sure_phase2<
-         typename boost::tuples::element<2, Args>::type
-       >::value
-    );
-};
-
-template <class Args> 
-struct throws_for_sure_phase2<
-  lambda_functor< 
-    lambda_functor_base< other_action<comma_action>, Args> 
-  > 
->
-{
-  static const bool value =
-    throws_for_sure_phase2<
-      typename boost::tuples::element<0, Args>::type
-    >::value
-    || 
-    throws_for_sure_phase2<
-      typename boost::tuples::element<1, Args>::type
-    >::value;
-};
-
-  // get rid of any qualifiers and references
-  // lambda_functors should be stored like that, so this is to be extra sure 
-template <class Arg> 
-struct throws_for_sure {
-  static const bool value 
-    = throws_for_sure_phase2<
-        typename detail::remove_reference_and_cv<Arg>::type
-      >::value;
-};
-
-
-// -- return_or_throw templates -----------------------------
-
-// false case, catch and try return types are incompatible
-// Now the catch part must throw for sure, otherwise a compile time error
-// occurs.
-template<bool is_conversion>
-struct return_or_throw_phase2 {
-  template<class RET, class Arg, CALL_TEMPLATE_ARGS>
-  static RET call(Arg& arg, CALL_FORMAL_ARGS) {
-    BOOST_STATIC_ASSERT(throws_for_sure<Arg>::value);
-    detail::select(arg, CALL_ACTUAL_ARGS); // this line throws
-    throw 1; // this line is never performed, hence 1 is just a dummy
-             // The line is needed to make compiler happy and not require
-             // a matching return type
-  }
-};
-
-// the try and catch return types are compatible
-template<>
-struct return_or_throw_phase2<true> {
-  template<class RET, class Arg, CALL_TEMPLATE_ARGS>
-  static RET call(Arg& arg, CALL_FORMAL_ARGS) {
-    return detail::select(arg, CALL_ACTUAL_ARGS);
-  }
-};
-
-
-// the non-void case. Try part returns a value, so catch parts must 
-// return a value of the same type or throw
-template<class RET, class ARG>
-struct return_or_throw {
-  // Arg should be equal to ARG except that ARG may be a reference
-  // to be sure, that there are no suprises for peculiarly defined return types
-  // ARG is passed explicitely
-  template<class Arg, CALL_TEMPLATE_ARGS>
-  static RET call(Arg& arg, CALL_FORMAL_ARGS)
-  {        
-    //    typedef typename Arg::return_type<ARG, open_args<A&, B&, C&> >::type RT;        
-    typedef typename as_lambda_functor<ARG>::type lf_type;
-    typedef typename lf_type::inherited::template 
-      sig<tuple<CALL_REFERENCE_TYPES> >::type RT;  
-
-    return 
-      return_or_throw_phase2<
-        ::boost::is_convertible<RT, RET>::value
-      >::template call<RET>(arg, CALL_ACTUAL_ARGS);
-  }
-};
-
-// if try part returns void, we do not return the catch parts either
-template<class ARG>
-struct return_or_throw<void, ARG> {
-  template<class Arg, CALL_TEMPLATE_ARGS>
-  static void call(Arg& arg, CALL_FORMAL_ARGS) { detail::select(arg, CALL_ACTUAL_ARGS); }
-};
-
-} // end detail
-
-// Throwing exceptions ---------------------------------------------
-
-namespace detail {
-
-template <class T> struct catch_block {}; 
-struct catch_all_block {};
-
-template <class T> struct exception_catch_tag {};
-
-// normal catch block is represented as
-// tagged_lambda_functor<exception_catch_tag<catch_type<T> > >, LambdaFunctor>
-  
-// the default catch all block as:
-// tagged_lambda_functor<exception_catch_tag<catch_all_block> >, LambdaFunctor>
-
-
-} // end detail
-
-// the code is RETHROW, this ensures that a compile time error results, 
-// if this lambda_functor is used outside a delayed catch_expression
-inline const 
-lambda_functor< 
-  lambda_functor_base< 
-    action<0, throw_action<rethrow_action> >, 
-    null_type
-  > 
->
-rethrow() { 
-  return 
-      lambda_functor_base< 
-        action<0, throw_action<rethrow_action> >,
-        null_type
-      > 
-    ( null_type() );
-}
-
-template <class Arg1>
-inline const 
-lambda_functor<
-  lambda_functor_base< 
-    action<1, throw_action<throw_new_action> >, 
-    tuple<typename const_copy_argument<const Arg1>::type>
-  > 
->
-throw_exception(const Arg1& a1) { 
-  return 
-      lambda_functor_base< 
-        action<1, throw_action<throw_new_action> >, 
-        tuple<typename const_copy_argument<const Arg1>::type>
-      > 
-    ( tuple<typename const_copy_argument<const Arg1>::type>(a1));
-}
-
-// create catch blocks
-template <class CatchType, class Arg>
-inline const 
-tagged_lambda_functor<
-  detail::exception_catch_tag<detail::catch_block<CatchType> >, 
-  lambda_functor<Arg> 
-> 
-catch_exception(const lambda_functor<Arg>& a) { 
-  // the third placeholder cannot be used in catch_exception
-  //    BOOST_STATIC_ASSERT((!has_placeholder<Arg, THIRD>::value));
-  return 
-    tagged_lambda_functor<
-      detail::exception_catch_tag<detail::catch_block<CatchType> >, 
-      lambda_functor<Arg> 
-    > (a);
-}
-
-// catch and do nothing case.
-template <class CatchType>
-inline const 
-tagged_lambda_functor<
-  detail::exception_catch_tag<detail::catch_block<CatchType> >, 
-  lambda_functor<
-    lambda_functor_base<
-      do_nothing_action,
-      null_type
-    > 
-  >
->
-catch_exception() { 
-  return 
-    tagged_lambda_functor<
-      detail::exception_catch_tag<detail::catch_block<CatchType> >, 
-      lambda_functor<
-        lambda_functor_base<
-          do_nothing_action,
-          null_type
-        > 
-      >
-    > ();
-}
-
-// create catch(...) blocks
-template <class Arg>
-inline const 
-tagged_lambda_functor<
-  detail::exception_catch_tag<detail::catch_all_block>, 
-  lambda_functor<Arg> 
-> 
-catch_all(const lambda_functor<Arg>& a) { 
-  // the third placeholder cannot be used in catch_exception
-  BOOST_STATIC_ASSERT((!has_placeholder<Arg, THIRD>::value));
-  return 
-    tagged_lambda_functor<
-      detail::exception_catch_tag<detail::catch_all_block>, 
-      lambda_functor<Arg> 
-    > (a);
-}
-
-// catch(...) and do nothing case.
-inline const 
-tagged_lambda_functor<
-  detail::exception_catch_tag<detail::catch_all_block>, 
-  lambda_functor<
-    lambda_functor_base<
-      do_nothing_action,
-      null_type
-    > 
-  >
->
-catch_all() { 
-  return 
-    tagged_lambda_functor<
-      detail::exception_catch_tag<detail::catch_all_block>, 
-      lambda_functor<
-        lambda_functor_base<
-          do_nothing_action,
-          null_type
-        > 
-      > 
-    > ();
-}
-
-// try_catch functions --------------------------------
-// The second -> N argument(s) are must be catch lambda_functors 
-template <class TryArg, class Catch1, class LF1>
-inline const 
-lambda_functor< 
-  lambda_functor_base< 
-    action<2, try_catch_action<catch_action<Catch1> > >, 
-    tuple<lambda_functor<TryArg>, LF1>
-  > 
->
-try_catch(
-  const lambda_functor<TryArg>& a1, 
-  const tagged_lambda_functor<detail::exception_catch_tag<Catch1>, LF1>& a2) 
-{ 
-  return 
-    lambda_functor_base< 
-      action<2, try_catch_action<catch_action<Catch1> > >, 
-      tuple<lambda_functor<TryArg>, LF1>
-    > 
-    ( tuple< lambda_functor<TryArg>, LF1>(a1, a2));
-}
-
-template <class TryArg, class Catch1, class LF1, 
-                        class Catch2, class LF2>
-inline const 
-  lambda_functor< 
-    lambda_functor_base< 
-      action<3, try_catch_action<catch_action<detail::catch_block<Catch1>, Catch2> > >, 
-      tuple<lambda_functor<TryArg>, LF1, LF2>
-    > 
->
-try_catch(
-  const lambda_functor<TryArg>& a1, 
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch1> >, LF1>& a2,
-  const tagged_lambda_functor<detail::exception_catch_tag<Catch2>, LF2>& a3) 
-{ 
-  return 
-    lambda_functor_base<
-      action<3, try_catch_action<catch_action<detail::catch_block<Catch1>, Catch2> > >, 
-      tuple<lambda_functor<TryArg>, LF1, LF2>
-    > 
-    ( tuple<lambda_functor<TryArg>, LF1, LF2>(a1, a2, a3));
-}
-
-template <class TryArg, class Catch1, class LF1, 
-                        class Catch2, class LF2, 
-                        class Catch3, class LF3>
-inline const lambda_functor< 
-  lambda_functor_base< 
-    action<4, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, Catch3> > >, 
-    tuple<lambda_functor<TryArg>, LF1, LF2, LF3>
-  > 
->
-try_catch(
-  const lambda_functor<TryArg>& a1, 
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch1> >, LF1>& a2,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch2> >, LF2>& a3,
-  const tagged_lambda_functor<detail::exception_catch_tag<Catch3>, LF3>& a4) 
-{ 
-  return 
-      lambda_functor_base< 
-        action<4, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, Catch3> > >, 
-        tuple<lambda_functor<TryArg>, LF1, LF2, LF3>
-      > 
-    ( tuple<lambda_functor<TryArg>, LF1, LF2, LF3>(a1, a2, a3, a4));
-}
-
-template <class TryArg, class Catch1, class LF1, 
-                        class Catch2, class LF2, 
-                        class Catch3, class LF3, 
-                        class Catch4, class LF4>
-inline const 
-lambda_functor< 
-  lambda_functor_base< 
-    action<
-      5, 
-      try_catch_action<
-        catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, Catch4> 
-      > 
-    >, 
-    tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4> 
-  > 
->
-try_catch(
-  const lambda_functor<TryArg>& a1, 
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch1> >, LF1>& a2,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch2> >, LF2>& a3,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch3> >, LF3>& a4,
-  const tagged_lambda_functor<detail::exception_catch_tag<Catch4>, LF4>& a5) 
-{ 
-  return 
-      lambda_functor_base< 
-        action<
-          5, 
-          try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, Catch4> > 
-        >, 
-        tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4>
-      > 
-    ( tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4>(a1, a2, a3, a4, a5));
-}
-
-template <class TryArg, class Catch1, class LF1, 
-                        class Catch2, class LF2, 
-                        class Catch3, class LF3, 
-                        class Catch4, class LF4, 
-                        class Catch5, class LF5>
-inline const 
-lambda_functor< 
-  lambda_functor_base< 
-    action<
-      6, 
-      try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, Catch5> >
-    >, 
-    tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5>
-  > 
->
-try_catch(
-  const lambda_functor<TryArg>& a1, 
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch1> >, LF1>& a2,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch2> >, LF2>& a3,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch3> >, LF3>& a4,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch4> >, LF4>& a5,
-  const tagged_lambda_functor<detail::exception_catch_tag<Catch5>, LF5>& a6) 
-{ 
-  return 
-      lambda_functor_base< 
-         action<
-           6, 
-           try_catch_action<
-             catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, Catch5> 
-           > 
-         >, 
-         tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5>
-      > 
-    ( tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5>
-        (a1, a2, a3, a4, a5, a6)
-    );
-}
-
-template <class TryArg, class Catch1, class LF1, 
-                        class Catch2, class LF2, 
-                        class Catch3, class LF3, 
-                        class Catch4, class LF4, 
-                        class Catch5, class LF5, 
-                        class Catch6, class LF6>
-inline const 
-lambda_functor< 
-  lambda_functor_base< 
-    action<
-      7, 
-      try_catch_action<
-        catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, Catch6> 
-      > 
-    >, 
-    tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6>
-  > 
->
-try_catch(
-  const lambda_functor<TryArg>& a1, 
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch1> >, LF1>& a2,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch2> >, LF2>& a3,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch3> >, LF3>& a4,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch4> >, LF4>& a5,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch5> >, LF5>& a6,
-  const tagged_lambda_functor<detail::exception_catch_tag<Catch6>, LF6>& a7) 
-{ 
-  return 
-      lambda_functor_base< 
-        action<
-          7, 
-          try_catch_action<
-            catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>,Catch6> 
-          > 
-        >, 
-        tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6>
-      > 
-    ( tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6>
-        (a1, a2, a3, a4, a5, a6, a7));
-}
-
-template <class TryArg, class Catch1, class LF1, 
-                        class Catch2, class LF2, 
-                        class Catch3, class LF3, 
-                        class Catch4, class LF4, 
-                        class Catch5, class LF5, 
-                        class Catch6, class LF6,
-                        class Catch7, class LF7>
-inline const 
-lambda_functor< 
-  lambda_functor_base< 
-    action<
-      8, 
-      try_catch_action<
-        catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>, Catch7> 
-      > 
-    >, 
-    tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7>
-  > 
->
-try_catch(
-  const lambda_functor<TryArg>& a1, 
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch1> >, LF1>& a2,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch2> >, LF2>& a3,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch3> >, LF3>& a4,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch4> >, LF4>& a5,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch5> >, LF5>& a6,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch6> >, LF6>& a7,
-  const tagged_lambda_functor<detail::exception_catch_tag<Catch7>, LF7>& a8) 
-{ 
-  return 
-      lambda_functor_base< 
-        action<
-          8, 
-          try_catch_action<
-            catch_action<
-              detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>, Catch7
-            > 
-          > 
-        >, 
-        tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7>
-      > 
-    ( tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7>
-        (a1, a2, a3, a4, a5, a6, a7, a8));
-}
-
-template <class TryArg, class Catch1, class LF1, 
-                        class Catch2, class LF2, 
-                        class Catch3, class LF3, 
-                        class Catch4, class LF4, 
-                        class Catch5, class LF5, 
-                        class Catch6, class LF6, 
-                        class Catch7, class LF7, 
-                        class Catch8, class LF8>
-inline const 
-lambda_functor< 
-  lambda_functor_base< 
-    action<
-      9, 
-      try_catch_action<
-        catch_action<
-          detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>, detail::catch_block<Catch7>, Catch8
-        > 
-      > 
-    >, 
-    tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7, LF8>
-  > 
->
-try_catch(
-  const lambda_functor<TryArg>& a1, 
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch1> >, LF1>& a2,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch2> >, LF2>& a3,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch3> >, LF3>& a4,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch4> >, LF4>& a5,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch5> >, LF5>& a6,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch6> >, LF6>& a7,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch7> >, LF7>& a8,
-  const tagged_lambda_functor<detail::exception_catch_tag<Catch8>, LF8>& a9) 
-{ 
-  return 
-      lambda_functor_base< 
-        action<
-          9,
-          try_catch_action<
-            catch_action<
-              detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>, detail::catch_block<Catch7>, Catch8
-            > 
-          > 
-        >, 
-        tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7, LF8> 
-      > 
-    ( tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7, LF8>
-        (a1, a2, a3, a4, a5, a6, a7, a8, a9));
-}
-
-template <class TryArg, class Catch1, class LF1, 
-                        class Catch2, class LF2, 
-                        class Catch3, class LF3, 
-                        class Catch4, class LF4, 
-                        class Catch5, class LF5, 
-                        class Catch6, class LF6, 
-                        class Catch7, class LF7, 
-                        class Catch8, class LF8, 
-                        class Catch9, class LF9>
-inline const 
-  lambda_functor< 
-    lambda_functor_base< 
-      action< 
-        10, 
-        try_catch_action<
-          catch_action<
-             detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>, detail::catch_block<Catch7>, detail::catch_block<Catch8>, 
-             Catch9
-          > 
-        > 
-      >, 
-      tuple<
-        lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7, LF8, LF9
-      >
-    > 
-  >
-try_catch(
-  const lambda_functor<TryArg>& a1, 
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch1> >, LF1>& a2,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch2> >, LF2>& a3,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch3> >, LF3>& a4,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch4> >, LF4>& a5,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch5> >, LF5>& a6,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch6> >, LF6>& a7,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch7> >, LF7>& a8,
-  const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch8> >, LF8>& a9,
-  const tagged_lambda_functor<detail::exception_catch_tag<Catch9>, LF9>& a10) 
-{ 
-  return 
-      lambda_functor_base< 
-        action<
-          10, 
-          try_catch_action< 
-            catch_action<
-              detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>, detail::catch_block<Catch7>, detail::catch_block<Catch8>, 
-              Catch9
-            > 
-          > 
-        >, 
-        tuple<
-          lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7, LF8, LF9
-        >
-      > 
-    ( tuple<
-        lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7, LF8, LF9
-      >(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10));
-}
-
-
-// ---------------------------------------------------------------------------
-// Specializations for lambda_functor_base of try_catch ----------------------
-
-// 1 catch type case
-
-template<class Args, class Catch1>
-class lambda_functor_base<
-  action<2, try_catch_action<catch_action<detail::catch_block<Catch1> > > >, 
-  Args
-> 
-{
-public:
-  Args args;
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-// the return type of try_catch is the return type of the try lambda_functor
-// (the return types of try and catch parts must match unless try returns void
-// or the catch part throws for sure)
-
-  template <class SigArgs> struct sig {
-    typedef typename 
-      as_lambda_functor<
-            typename boost::tuples::element<0, Args>::type 
-      >::type lf_type;
-
-    typedef typename lf_type::inherited::template sig<SigArgs>::type type;  
-  };
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    try 
-    {
-      return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS);
-    }
-    catch (Catch1& e)
-    {                
-      return 
-       detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type>
-               ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-  }
-};
-
-
-
-template<class Args>
-class lambda_functor_base<action<2, try_catch_action<catch_action<detail::catch_all_block> > >, Args> {
-public:
-  Args args;
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template <class SigArgs> struct sig {
-    typedef typename 
-      as_lambda_functor<
-            typename boost::tuples::element<0, Args>::type 
-      >::type lf_type;
-
-    typedef typename lf_type::inherited::template sig<SigArgs>::type type;  
-  };
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    try 
-    {
-      return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS);  
-    }
-    catch (...)
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type>
-               ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS);
-    }
-  }
-};
-
-
-// 2 catch types case
-template<class Args, class Catch1, class Catch2>
-class lambda_functor_base<action<3, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2> > > >, Args> {
-public:
-  Args args;
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template <class SigArgs> struct sig {
-    typedef typename 
-      as_lambda_functor<
-            typename boost::tuples::element<0, Args>::type 
-      >::type lf_type;
-
-    typedef typename lf_type::inherited::template sig<SigArgs>::type type;  
-  };
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    try 
-    {
-      return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS);  
-    }
-    catch (Catch1& e)
-    { 
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type>
-               ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch2& e)
-    {          
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type>
-               ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-  }
-};
-
-template<class Args, class Catch1>
-class lambda_functor_base<action<3, try_catch_action<catch_action<detail::catch_block<Catch1>,detail::catch_all_block> > >, Args> {
-public:
-  Args args;
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template <class SigArgs> struct sig {
-    typedef typename 
-      as_lambda_functor<
-            typename boost::tuples::element<0, Args>::type 
-      >::type lf_type;
-
-    typedef typename lf_type::inherited::template sig<SigArgs>::type type;  
-  };
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    try 
-    {
-      return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS);  
-    }
-    catch (Catch1& e)
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type>
-               ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (...)
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type>
-               ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS);
-    }
-  }
-};
-
-// 3 catch types case
-template<class Args, class Catch1, class Catch2, class Catch3>
-class lambda_functor_base<action<4, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3> > > >, Args> {
-public:
-  Args args;
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template <class SigArgs> struct sig {
-    typedef typename 
-      as_lambda_functor<
-            typename boost::tuples::element<0, Args>::type 
-      >::type lf_type;
-
-    typedef typename lf_type::inherited::template sig<SigArgs>::type type;  
-  };
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    try 
-    {
-      return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS);  
-    }
-    catch (Catch1& e)
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type>
-               ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-
-    }
-    catch (Catch2& e)
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type>
-               ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-
-    }
-    catch (Catch3& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type>
-               ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-  }
-};
-
-template<class Args, class Catch1, class Catch2>
-class lambda_functor_base<action<4, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>,detail::catch_all_block> > >, Args> {
-public:
-  Args args;
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template <class SigArgs> struct sig {
-    typedef typename 
-      as_lambda_functor<
-            typename boost::tuples::element<0, Args>::type 
-      >::type lf_type;
-
-    typedef typename lf_type::inherited::template sig<SigArgs>::type type;  
-  };
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    try 
-    {
-      return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS);  
-    }
-    catch (Catch1& e)
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type>
-               ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch2& e)
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type>
-               ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (...)
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type>
-               ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS);
-    }
-  }
-};
-
-// 4 catch types case
-template<class Args, class Catch1, class Catch2, class Catch3, class Catch4>
-class lambda_functor_base<action<5, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4> > > >, Args> {
-public:
-  Args args;
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template <class SigArgs> struct sig {
-    typedef typename 
-      as_lambda_functor<
-            typename boost::tuples::element<0, Args>::type 
-      >::type lf_type;
-
-    typedef typename lf_type::inherited::template sig<SigArgs>::type type;  
-  };
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    try 
-    {
-      return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS);  
-    }
-    catch (Catch1& e)
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type>
-               ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch2& e) 
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type>
-               ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch3& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type>
-               ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch4& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type>
-               ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-  }
-};
-
-template<class Args, class Catch1, class Catch2, class Catch3>
-class lambda_functor_base<action<5, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>,detail::catch_all_block> > >, Args> {
-public:
-  Args args;
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template <class SigArgs> struct sig {
-    typedef typename 
-      as_lambda_functor<
-            typename boost::tuples::element<0, Args>::type 
-      >::type lf_type;
-
-    typedef typename lf_type::inherited::template sig<SigArgs>::type type;  
-  };
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    try 
-    {
-      return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS);  
-    }
-    catch (Catch1& e)
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type>
-               ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch2& e) 
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type>
-               ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch3& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type>
-               ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (...)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type>
-               ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS);
-    }
-  }
-};
-
-// 5 catch types case
-template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5>
-class lambda_functor_base<action<6, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5> > > >, Args> {
-public:
-  Args args;
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template <class SigArgs> struct sig {
-    typedef typename 
-      as_lambda_functor<
-            typename boost::tuples::element<0, Args>::type 
-      >::type lf_type;
-
-    typedef typename lf_type::inherited::template sig<SigArgs>::type type;  
-  };
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    try 
-    {
-      return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS);  
-    }
-    catch (Catch1& e)
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type>
-               ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch2& e) 
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type>
-               ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch3& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type>
-               ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch4& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type>
-               ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch5& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type>
-               ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-  }
-};
-
-template<class Args, class Catch1, class Catch2, class Catch3, class Catch4>
-class lambda_functor_base<action<6, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>,detail::catch_all_block> > >, Args> {
-public:
-  Args args;
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template <class SigArgs> struct sig {
-    typedef typename 
-      as_lambda_functor<
-            typename boost::tuples::element<0, Args>::type 
-      >::type lf_type;
-
-    typedef typename lf_type::inherited::template sig<SigArgs>::type type;  
-  };
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    try 
-    {
-      return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS);  
-    }
-    catch (Catch1& e)
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type>
-               ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch2& e) 
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type>
-               ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch3& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type>
-               ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch4& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type>
-               ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (...)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type>
-               ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS);
-    }
-  }
-};
-
-// 6 catch types case
-template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5, class Catch6>
-class lambda_functor_base<action<7, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6> > > >, Args> {
-public:
-  Args args;
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template <class SigArgs> struct sig {
-    typedef typename 
-      as_lambda_functor<
-            typename boost::tuples::element<0, Args>::type 
-      >::type lf_type;
-
-    typedef typename lf_type::inherited::template sig<SigArgs>::type type;  
-  };
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    try 
-    {
-      return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS);  
-    }
-    catch (Catch1& e)
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type>
-               ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch2& e) 
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type>
-               ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch3& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type>
-               ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch4& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type>
-               ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch5& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type>
-               ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch6& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<6, Args>::type>
-               ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-  }
-};
-
-template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5>
-class lambda_functor_base<action<7, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>,detail::catch_all_block> > >, Args> {
-public:
-  Args args;
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template <class SigArgs> struct sig {
-    typedef typename 
-      as_lambda_functor<
-            typename boost::tuples::element<0, Args>::type 
-      >::type lf_type;
-
-    typedef typename lf_type::inherited::template sig<SigArgs>::type type;  
-  };
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    try 
-    {
-      return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS);  
-    }
-    catch (Catch1& e)
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type>
-               ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch2& e) 
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type>
-               ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch3& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type>
-               ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch4& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type>
-               ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch5& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type>
-               ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (...)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<6, Args>::type>
-               ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS);
-    }
-  }
-};
-
-// 7 catch types case
-template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5, class Catch6,
-                     class Catch7>
-class lambda_functor_base<action<8, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>, detail::catch_block<Catch7> > > >, Args> {
-public:
-  Args args;
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template <class SigArgs> struct sig {
-    typedef typename 
-      as_lambda_functor<
-            typename boost::tuples::element<0, Args>::type 
-      >::type lf_type;
-
-    typedef typename lf_type::inherited::template sig<SigArgs>::type type;  
-  };
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    try 
-    {
-      return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS);  
-    }
-    catch (Catch1& e)
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type>
-               ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch2& e) 
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type>
-               ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch3& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type>
-               ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch4& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type>
-               ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch5& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type>
-               ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch6& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<6, Args>::type>
-               ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch7& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<7, Args>::type>
-               ::call(::boost::tuples::get<7>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-  }
-};
-
-template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5, class Catch6>
-class lambda_functor_base<action<8, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>,
-                                                               detail::catch_all_block> > >, Args> {
-public:
-  Args args;
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template <class SigArgs> struct sig {
-    typedef typename 
-      as_lambda_functor<
-            typename boost::tuples::element<0, Args>::type 
-      >::type lf_type;
-
-    typedef typename lf_type::inherited::template sig<SigArgs>::type type;  
-  };
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    try 
-    {
-      return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS);  
-    }
-    catch (Catch1& e)
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type>
-               ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch2& e) 
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type>
-               ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch3& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type>
-               ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch4& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type>
-               ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch5& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type>
-               ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch6& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<6, Args>::type>
-               ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (...)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<7, Args>::type>
-               ::call(::boost::tuples::get<7>(args), CALL_ACTUAL_ARGS);
-    }
-  }
-};
-
-// 8 catch types case
-template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5, class Catch6,
-                     class Catch7, class Catch8>
-class lambda_functor_base<action<9, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>,
-    detail::catch_block<Catch7>, detail::catch_block<Catch8> > > >, Args> {
-public:
-  Args args;
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template <class SigArgs> struct sig {
-    typedef typename 
-      as_lambda_functor<
-            typename boost::tuples::element<0, Args>::type 
-      >::type lf_type;
-
-    typedef typename lf_type::inherited::template sig<SigArgs>::type type;  
-  };
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    try 
-    {
-      return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS);  
-    }
-    catch (Catch1& e)
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type>
-               ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch2& e) 
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type>
-               ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch3& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type>
-               ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch4& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type>
-               ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch5& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type>
-               ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch6& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<6, Args>::type>
-               ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch7& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<7, Args>::type>
-               ::call(::boost::tuples::get<7>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch8& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<8, Args>::type>
-               ::call(::boost::tuples::get<8>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-  }
-};
-
-template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5, class Catch6,
-                     class Catch7>
-class lambda_functor_base<action<9, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>,
-    detail::catch_block<Catch7>,detail::catch_all_block> > >, Args> {
-public:
-  Args args;
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template <class SigArgs> struct sig {
-    typedef typename 
-      as_lambda_functor<
-            typename boost::tuples::element<0, Args>::type 
-      >::type lf_type;
-
-    typedef typename lf_type::inherited::template sig<SigArgs>::type type;  
-  };
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    try 
-    {
-      return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS);  
-    }
-    catch (Catch1& e)
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type>
-               ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch2& e) 
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type>
-               ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch3& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type>
-               ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch4& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type>
-               ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch5& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type>
-               ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch6& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<6, Args>::type>
-               ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch7& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<7, Args>::type>
-               ::call(::boost::tuples::get<7>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (...)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<8, Args>::type>
-               ::call(::boost::tuples::get<8>(args), CALL_ACTUAL_ARGS);
-    }
-  }
-};
-
-// 9 catch types case
-template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5, class Catch6,
-                     class Catch7, class Catch8, class Catch9>
-class lambda_functor_base<action<10, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>,
-    detail::catch_block<Catch7>, detail::catch_block<Catch8>, detail::catch_block<Catch9> > > >, Args> {
-public:
-  Args args;
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template <class SigArgs> struct sig {
-    typedef typename 
-      as_lambda_functor<
-            typename boost::tuples::element<0, Args>::type 
-      >::type lf_type;
-
-    typedef typename lf_type::inherited::template sig<SigArgs>::type type;  
-  };
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    try 
-    {
-      return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS);  
-    }
-    catch (Catch1& e)
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type>
-               ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch2& e) 
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type>
-               ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch3& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type>
-               ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch4& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type>
-               ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch5& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type>
-               ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch6& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<6, Args>::type>
-               ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch7& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<7, Args>::type>
-               ::call(::boost::tuples::get<7>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch8& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<8, Args>::type>
-               ::call(::boost::tuples::get<8>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch9& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<9, Args>::type>
-               ::call(::boost::tuples::get<9>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-  }
-};
-
-template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5, class Catch6,
-                     class Catch7, class Catch8>
-class lambda_functor_base<action<10, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>,
-    detail::catch_block<Catch7>, detail::catch_block<Catch8>,detail::catch_all_block> > >, Args> {
-public:
-  Args args;
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template <class SigArgs> struct sig {
-    typedef typename 
-      as_lambda_functor<
-            typename boost::tuples::element<0, Args>::type 
-      >::type lf_type;
-
-    typedef typename lf_type::inherited::template sig<SigArgs>::type type;  
-  };
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    try 
-    {
-      return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS);  
-    }
-    catch (Catch1& e)
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type>
-               ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch2& e) 
-    {                
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type>
-               ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch3& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type>
-               ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch4& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type>
-               ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch5& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type>
-               ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch6& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<6, Args>::type>
-               ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch7& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<7, Args>::type>
-               ::call(::boost::tuples::get<7>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (Catch8& e)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<8, Args>::type>
-               ::call(::boost::tuples::get<8>(args), CALL_ACTUAL_ARGS_NO_ENV, e);
-    }
-    catch (...)
-    {
-      return 
-        detail::return_or_throw<RET, typename ::boost::tuples::element<9, Args>::type>
-               ::call(::boost::tuples::get<9>(args), CALL_ACTUAL_ARGS);
-    }
-  }
-};
-
-
-} // namespace lambda 
-} // namespace boost
-
-
-#endif
-
-
-
-
-
-
diff --git a/contrib/restricted/boost/boost/lambda/if.hpp b/contrib/restricted/boost/boost/lambda/if.hpp
deleted file mode 100644
index 08f45f984a..0000000000
--- a/contrib/restricted/boost/boost/lambda/if.hpp
+++ /dev/null
@@ -1,462 +0,0 @@
-// Boost Lambda Library -- if.hpp ------------------------------------------
-
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2000 Gary Powell (powellg@amazon.com)
-// Copyright (C) 2001-2002 Joel de Guzman
-//
-// Distributed under 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)
-//
-// For more information, see www.boost.org
-
-// --------------------------------------------------------------------------
-
-#if !defined(BOOST_LAMBDA_IF_HPP)
-#define BOOST_LAMBDA_IF_HPP
-
-#include "boost/lambda/core.hpp"
-
-// Arithmetic type promotion needed for if_then_else_return
-#include "boost/lambda/detail/operator_actions.hpp"
-#include "boost/lambda/detail/operator_return_type_traits.hpp"
-
-namespace boost { 
-namespace lambda {
-
-// -- if control construct actions ----------------------
-
-class ifthen_action {};
-class ifthenelse_action {};
-class ifthenelsereturn_action {};
-
-// Specialization for if_then.
-template<class Args>
-class 
-lambda_functor_base<ifthen_action, Args> {
-public:
-  Args args;
-  template <class T> struct sig { typedef void type; };
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    if (detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS)) 
-      detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); 
-  }
-};
-
-// If Then
-template <class Arg1, class Arg2>
-inline const 
-lambda_functor<
-  lambda_functor_base<
-    ifthen_action, 
-    tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
-  > 
->
-if_then(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2) {
-  return 
-    lambda_functor_base<
-      ifthen_action, 
-      tuple<lambda_functor<Arg1>, lambda_functor<Arg2> > 
-    > 
-    ( tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >(a1, a2) );
-}
-
-
-// Specialization for if_then_else.
-template<class Args>
-class 
-lambda_functor_base<ifthenelse_action, Args> {
-public:
-  Args args;
-  template <class T> struct sig { typedef void type; };
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    if (detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS)) 
-      detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); 
-    else 
-      detail::select(boost::tuples::get<2>(args), CALL_ACTUAL_ARGS);
-  }
-};
-
-
-
-// If then else
-
-template <class Arg1, class Arg2, class Arg3>
-inline const 
-lambda_functor<
-  lambda_functor_base<
-    ifthenelse_action, 
-    tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, lambda_functor<Arg3> >
-  > 
->
-if_then_else(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2, 
-             const lambda_functor<Arg3>& a3) {
-  return 
-    lambda_functor_base<
-      ifthenelse_action, 
-      tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, lambda_functor<Arg3> >
-    > 
-    (tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, lambda_functor<Arg3> >
-       (a1, a2, a3) );
-}
-
-// Our version of operator?:()
-
-template <class Arg1, class Arg2, class Arg3>
-inline const 
-  lambda_functor<
-    lambda_functor_base<
-      other_action<ifthenelsereturn_action>, 
-      tuple<lambda_functor<Arg1>,
-          typename const_copy_argument<Arg2>::type,
-          typename const_copy_argument<Arg3>::type>
-  > 
->
-if_then_else_return(const lambda_functor<Arg1>& a1, 
-                    const Arg2 & a2, 
-                    const Arg3 & a3) {
-  return 
-      lambda_functor_base<
-        other_action<ifthenelsereturn_action>, 
-        tuple<lambda_functor<Arg1>,
-              typename const_copy_argument<Arg2>::type,
-              typename const_copy_argument<Arg3>::type>
-      > ( tuple<lambda_functor<Arg1>,
-              typename const_copy_argument<Arg2>::type,
-              typename const_copy_argument<Arg3>::type> (a1, a2, a3) );
-}
-
-namespace detail {
-
-// return type specialization for conditional expression begins -----------
-// start reading below and move upwards
-
-// PHASE 6:1 
-// check if A is conbertible to B and B to A
-template<int Phase, bool AtoB, bool BtoA, bool SameType, class A, class B>
-struct return_type_2_ifthenelsereturn;
-
-// if A can be converted to B and vice versa -> ambiguous
-template<int Phase, class A, class B>
-struct return_type_2_ifthenelsereturn<Phase, true, true, false, A, B> {
-  typedef 
-    detail::return_type_deduction_failure<return_type_2_ifthenelsereturn> type;
-  // ambiguous type in conditional expression
-};
-// if A can be converted to B and vice versa and are of same type
-template<int Phase, class A, class B>
-struct return_type_2_ifthenelsereturn<Phase, true, true, true, A, B> {
-  typedef A type;
-};
-
-
-// A can be converted to B
-template<int Phase, class A, class B>
-struct return_type_2_ifthenelsereturn<Phase, true, false, false, A, B> {
-  typedef B type;
-};
-
-// B can be converted to A
-template<int Phase, class A, class B>
-struct return_type_2_ifthenelsereturn<Phase, false, true, false, A, B> {
-  typedef A type;
-};
-
-// neither can be converted. Then we drop the potential references, and
-// try again
-template<class A, class B>
-struct return_type_2_ifthenelsereturn<1, false, false, false, A, B> {
-  // it is safe to add const, since the result will be an rvalue and thus
-  // const anyway. The const are needed eg. if the types 
-  // are 'const int*' and 'void *'. The remaining type should be 'const void*'
-  typedef const typename boost::remove_reference<A>::type plainA; 
-  typedef const typename boost::remove_reference<B>::type plainB; 
-  // TODO: Add support for volatile ?
-
-  typedef typename
-       return_type_2_ifthenelsereturn<
-         2,
-         boost::is_convertible<plainA,plainB>::value, 
-         boost::is_convertible<plainB,plainA>::value,
-         boost::is_same<plainA,plainB>::value,
-         plainA, 
-         plainB>::type type;
-};
-
-// PHASE 6:2
-template<class A, class B>
-struct return_type_2_ifthenelsereturn<2, false, false, false, A, B> {
-  typedef 
-    detail::return_type_deduction_failure<return_type_2_ifthenelsereturn> type;
-  // types_do_not_match_in_conditional_expression 
-};
-
-
-
-// PHASE 5: now we know that types are not arithmetic.
-template<class A, class B>
-struct non_numeric_types {
-  typedef typename 
-    return_type_2_ifthenelsereturn<
-      1, // phase 1 
-      is_convertible<A,B>::value, 
-      is_convertible<B,A>::value, 
-      is_same<A,B>::value,
-      A, 
-      B>::type type;
-};
-
-// PHASE 4 : 
-// the base case covers arithmetic types with differing promote codes
-// use the type deduction of arithmetic_actions
-template<int CodeA, int CodeB, class A, class B>
-struct arithmetic_or_not {
-  typedef typename
-    return_type_2<arithmetic_action<plus_action>, A, B>::type type; 
-  // plus_action is just a random pick, has to be a concrete instance
-};
-
-// this case covers the case of artihmetic types with the same promote codes. 
-// non numeric deduction is used since e.g. integral promotion is not 
-// performed with operator ?: 
-template<int CodeA, class A, class B>
-struct arithmetic_or_not<CodeA, CodeA, A, B> {
-  typedef typename non_numeric_types<A, B>::type type; 
-};
-
-// if either A or B has promote code -1 it is not an arithmetic type
-template<class A, class B>
-struct arithmetic_or_not <-1, -1, A, B> {
-  typedef typename non_numeric_types<A, B>::type type;
-};
-template<int CodeB, class A, class B>
-struct arithmetic_or_not <-1, CodeB, A, B> {
-  typedef typename non_numeric_types<A, B>::type type;
-};
-template<int CodeA, class A, class B>
-struct arithmetic_or_not <CodeA, -1, A, B> {
-  typedef typename non_numeric_types<A, B>::type type;
-};
-
-
-
-
-// PHASE 3 : Are the types same?
-// No, check if they are arithmetic or not
-template <class A, class B>
-struct same_or_not {
-  typedef typename detail::remove_reference_and_cv<A>::type plainA;
-  typedef typename detail::remove_reference_and_cv<B>::type plainB;
-
-  typedef typename 
-    arithmetic_or_not<
-      detail::promote_code<plainA>::value, 
-      detail::promote_code<plainB>::value, 
-      A, 
-      B>::type type;
-};
-// Yes, clear.
-template <class A> struct same_or_not<A, A> {
-  typedef A type;
-};
-
-} // detail
-
-// PHASE 2 : Perform first the potential array_to_pointer conversion 
-template<class A, class B>
-struct return_type_2<other_action<ifthenelsereturn_action>, A, B> { 
-
-  typedef typename detail::array_to_pointer<A>::type A1;
-  typedef typename detail::array_to_pointer<B>::type B1;
-
-  typedef typename 
-    boost::add_const<typename detail::same_or_not<A1, B1>::type>::type type;
-};
-
-// PHASE 1 : Deduction is based on the second and third operand
-
-
-// return type specialization for conditional expression ends -----------
-
-
-// Specialization of lambda_functor_base for if_then_else_return.
-template<class Args>
-class 
-lambda_functor_base<other_action<ifthenelsereturn_action>, Args> {
-public:
-  Args args;
-
-  template <class SigArgs> struct sig {
-  private:
-    typedef typename detail::nth_return_type_sig<1, Args, SigArgs>::type ret1;
-    typedef typename detail::nth_return_type_sig<2, Args, SigArgs>::type ret2;
-  public:
-    typedef typename return_type_2<
-      other_action<ifthenelsereturn_action>, ret1, ret2
-    >::type type;
-  };
-
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    return (detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS)) ?
-       detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS) 
-    : 
-       detail::select(boost::tuples::get<2>(args), CALL_ACTUAL_ARGS);
-  }
-};
-
-  // The code below is from Joel de Guzman, some name changes etc. 
-  // has been made.
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  if_then_else_composite
-//
-//      This composite has two (2) forms:
-//
-//          if_(condition)
-//          [
-//              statement
-//          ]
-//
-//      and
-//
-//          if_(condition)
-//          [
-//              true_statement
-//          ]
-//          .else_
-//          [
-//              false_statement
-//          ]
-//
-//      where condition is an lambda_functor that evaluates to bool. If condition
-//      is true, the true_statement (again an lambda_functor) is executed
-//      otherwise, the false_statement (another lambda_functor) is executed. The
-//      result type of this is void. Note the trailing underscore after
-//      if_ and the leading dot and the trailing underscore before
-//      and after .else_.
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename CondT, typename ThenT, typename ElseT>
-struct if_then_else_composite {
-
-    typedef if_then_else_composite<CondT, ThenT, ElseT> self_t;
-
-    template <class SigArgs>
-    struct sig { typedef void type; };
-
-    if_then_else_composite(
-        CondT const& cond_,
-        ThenT const& then_,
-        ElseT const& else__)
-    :   cond(cond_), then(then_), else_(else__) {}
-
-    template <class Ret, CALL_TEMPLATE_ARGS>
-    Ret call(CALL_FORMAL_ARGS) const
-    {
-        if (cond.internal_call(CALL_ACTUAL_ARGS))
-            then.internal_call(CALL_ACTUAL_ARGS);
-        else
-            else_.internal_call(CALL_ACTUAL_ARGS);
-    }
-
-    CondT cond; ThenT then; ElseT else_; //  lambda_functors
-};
-
-//////////////////////////////////
-template <typename CondT, typename ThenT>
-struct else_gen {
-
-    else_gen(CondT const& cond_, ThenT const& then_)
-    :   cond(cond_), then(then_) {}
-
-    template <typename ElseT>
-    lambda_functor<if_then_else_composite<CondT, ThenT,
-        typename as_lambda_functor<ElseT>::type> >
-    operator[](ElseT const& else_)
-    {
-        typedef if_then_else_composite<CondT, ThenT,
-            typename as_lambda_functor<ElseT>::type>
-        result;
-
-        return result(cond, then, to_lambda_functor(else_));
-    }
-
-    CondT cond; ThenT then;
-};
-
-//////////////////////////////////
-template <typename CondT, typename ThenT>
-struct if_then_composite {
-
-    template <class SigArgs>
-    struct sig { typedef void type; };
-
-    if_then_composite(CondT const& cond_, ThenT const& then_)
-    :   cond(cond_), then(then_), else_(cond, then) {}
-
-    template <class Ret, CALL_TEMPLATE_ARGS>
-    Ret call(CALL_FORMAL_ARGS) const
-    {
-      if (cond.internal_call(CALL_ACTUAL_ARGS))
-            then.internal_call(CALL_ACTUAL_ARGS);
-    }
-
-    CondT cond; ThenT then; //  lambda_functors
-    else_gen<CondT, ThenT> else_;
-};
-
-//////////////////////////////////
-template <typename CondT>
-struct if_gen {
-
-    if_gen(CondT const& cond_)
-    :   cond(cond_) {}
-
-    template <typename ThenT>
-    lambda_functor<if_then_composite<
-        typename as_lambda_functor<CondT>::type,
-        typename as_lambda_functor<ThenT>::type> >
-    operator[](ThenT const& then) const
-    {
-        typedef if_then_composite<
-            typename as_lambda_functor<CondT>::type,
-            typename as_lambda_functor<ThenT>::type>
-        result;
-
-        return result(
-            to_lambda_functor(cond),
-            to_lambda_functor(then));
-    }
-
-    CondT cond;
-};
-
-//////////////////////////////////
-template <typename CondT>
-inline if_gen<CondT>
-if_(CondT const& cond)
-{
-    return if_gen<CondT>(cond);
-}
-
-
-
-} // lambda
-} // boost
-
-#endif // BOOST_LAMBDA_IF_HPP
-
-
diff --git a/contrib/restricted/boost/boost/lambda/lambda.hpp b/contrib/restricted/boost/boost/lambda/lambda.hpp
deleted file mode 100644
index e1654a2964..0000000000
--- a/contrib/restricted/boost/boost/lambda/lambda.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-// -- lambda.hpp -- Boost Lambda Library -----------------------------------
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//
-// Distributed under 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)
-//
-// For more information, see http://lambda.cs.utu.fi 
-
-#ifndef BOOST_LAMBDA_LAMBDA_HPP
-#define BOOST_LAMBDA_LAMBDA_HPP
-
-
-#include "boost/lambda/core.hpp"
-
-#ifdef BOOST_NO_FDECL_TEMPLATES_AS_TEMPLATE_TEMPLATE_PARAMS
-#include <istream>
-#include <ostream>
-#endif
-
-#include "boost/lambda/detail/operator_actions.hpp"
-#include "boost/lambda/detail/operator_lambda_func_base.hpp"
-#include "boost/lambda/detail/operator_return_type_traits.hpp"
-
-
-#include "boost/lambda/detail/operators.hpp"
-#include "boost/lambda/detail/member_ptr.hpp"
-
-#endif
diff --git a/contrib/restricted/boost/boost/lambda/loops.hpp b/contrib/restricted/boost/boost/lambda/loops.hpp
deleted file mode 100644
index bd85694beb..0000000000
--- a/contrib/restricted/boost/boost/lambda/loops.hpp
+++ /dev/null
@@ -1,505 +0,0 @@
-// Boost Lambda Library -- loops.hpp ----------------------------------------
-
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2000 Gary Powell (powellg@amazon.com)
-// Copyright (c) 2001-2002 Joel de Guzman
-//
-// Distributed under 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)
-//
-// For more information, see www.boost.org
-
-// --------------------------------------------------------------------------
-
-#if !defined(BOOST_LAMBDA_LOOPS_HPP)
-#define BOOST_LAMBDA_LOOPS_HPP
-
-#include "boost/lambda/core.hpp"
-
-namespace boost { 
-namespace lambda {
-
-// -- loop control structure actions ----------------------
-
-class forloop_action {};
-class forloop_no_body_action {};
-class whileloop_action {};
-class whileloop_no_body_action {};
-class dowhileloop_action {};
-class dowhileloop_no_body_action {};
-
-
-// For loop
-template <class Arg1, class Arg2, class Arg3, class Arg4>
-inline const 
-lambda_functor<
-  lambda_functor_base<
-    forloop_action, 
-    tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, 
-          lambda_functor<Arg3>, lambda_functor<Arg4> >
-  > 
->
-for_loop(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2, 
-         const lambda_functor<Arg3>& a3, const lambda_functor<Arg4>& a4) { 
-  return 
-      lambda_functor_base<
-        forloop_action, 
-        tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, 
-              lambda_functor<Arg3>, lambda_functor<Arg4> >
-      > 
-    ( tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, 
-            lambda_functor<Arg3>, lambda_functor<Arg4> >(a1, a2, a3, a4)
-    );
-}
-
-// No body case.
-template <class Arg1, class Arg2, class Arg3>
-inline const 
-lambda_functor<
-  lambda_functor_base<
-    forloop_no_body_action, 
-    tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, lambda_functor<Arg3> >
-  > 
->
-for_loop(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2, 
-         const lambda_functor<Arg3>& a3) { 
-  return 
-      lambda_functor_base<
-        forloop_no_body_action, 
-        tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, 
-              lambda_functor<Arg3> >
-      > 
-      ( tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, 
-               lambda_functor<Arg3> >(a1, a2, a3) );
-}
-
-// While loop
-template <class Arg1, class Arg2>
-inline const 
-lambda_functor<
-  lambda_functor_base<
-    whileloop_action, 
-    tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
-  > 
->
-while_loop(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2) { 
-  return 
-      lambda_functor_base<
-        whileloop_action, 
-        tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
-      > 
-      ( tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >(a1, a2));
-}
-
-// No body case.
-template <class Arg1>
-inline const 
-lambda_functor<
-  lambda_functor_base<
-    whileloop_no_body_action, 
-    tuple<lambda_functor<Arg1> >
-  > 
->
-while_loop(const lambda_functor<Arg1>& a1) { 
-  return 
-      lambda_functor_base<
-        whileloop_no_body_action, 
-        tuple<lambda_functor<Arg1> >
-      > 
-      ( tuple<lambda_functor<Arg1> >(a1) );
-}
-
-
-// Do While loop
-template <class Arg1, class Arg2>
-inline const 
-lambda_functor<
-  lambda_functor_base<
-    dowhileloop_action, 
-    tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
-  > 
->
-do_while_loop(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2) {
-  return 
-      lambda_functor_base<
-        dowhileloop_action, 
-        tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
-      > 
-      ( tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >(a1, a2));
-}
-
-// No body case.
-template <class Arg1>
-inline const 
-lambda_functor<
-  lambda_functor_base<
-    dowhileloop_no_body_action, 
-    tuple<lambda_functor<Arg1> >
-  > 
->
-do_while_loop(const lambda_functor<Arg1>& a1) { 
-  return 
-      lambda_functor_base<
-        dowhileloop_no_body_action, 
-        tuple<lambda_functor<Arg1> >
-      > 
-      ( tuple<lambda_functor<Arg1> >(a1));
-}
-
-
-// Control loop lambda_functor_base specializations.
-
-// Specialization for for_loop.
-template<class Args>
-class 
-lambda_functor_base<forloop_action, Args> {
-public:
-  Args args;
-  template <class T> struct sig { typedef void type; };
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    for(detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); 
-        detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); 
-        detail::select(boost::tuples::get<2>(args), CALL_ACTUAL_ARGS))
-      
-      detail::select(boost::tuples::get<3>(args), CALL_ACTUAL_ARGS);
-  }
-};
-
-// No body case
-template<class Args>
-class 
-lambda_functor_base<forloop_no_body_action, Args> {
-public:
-  Args args;
-  template <class T> struct sig { typedef void type; };
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    for(detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); 
-        detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); 
-        detail::select(boost::tuples::get<2>(args), CALL_ACTUAL_ARGS)) {}
-   }
-};
-
-
-// Specialization for while_loop.
-template<class Args>
-class 
-lambda_functor_base<whileloop_action, Args> {
-public:
-  Args args;
-  template <class T> struct sig { typedef void type; };
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    while(detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS))
-      
-      detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS);
-  }
-};
-
-// No body case
-template<class Args> 
-class 
-lambda_functor_base<whileloop_no_body_action, Args> {
-public:
-  Args args;
-  template <class T> struct sig { typedef void type; };
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-          while(detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS)) {}
-  }
-};
-
-// Specialization for do_while_loop.
-// Note that the first argument is the condition.
-template<class Args>
-class 
-lambda_functor_base<dowhileloop_action, Args> {
-public:
-  Args args;
-  template <class T> struct sig { typedef void type; };
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    do {
-      detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS);      
-    } while (detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) );
-  }
-};
-
-// No body case
-template<class Args>
-class 
-lambda_functor_base<dowhileloop_no_body_action, Args> {
-public:
-  Args args;
-  template <class T> struct sig { typedef void type; };
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-          do {} while (detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) );
-  }
-};
-
-  // The code below is from Joel de Guzman, some name changes etc. 
-  // has been made.
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  while_composite
-//
-//      This composite has the form:
-//
-//          while_(condition)
-//          [
-//              statement
-//          ]
-//
-//      While the condition (an lambda_functor) evaluates to true, statement
-//      (another lambda_functor) is executed. The result type of this is void.
-//      Note the trailing underscore after while_.
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename CondT, typename DoT>
-struct while_composite {
-
-    typedef while_composite<CondT, DoT> self_t;
-
-    template <class SigArgs>
-    struct sig { typedef void type; };
-
-    while_composite(CondT const& cond_, DoT const& do__)
-    :   cond(cond_), do_(do__) {}
-
-    template <class Ret, CALL_TEMPLATE_ARGS>
-    Ret call(CALL_FORMAL_ARGS) const
-    {
-        while (cond.internal_call(CALL_ACTUAL_ARGS))
-            do_.internal_call(CALL_ACTUAL_ARGS);
-    }
-
-    CondT cond;
-    DoT do_;
-};
-
-//////////////////////////////////
-template <typename CondT>
-struct while_gen {
-
-    while_gen(CondT const& cond_)
-    :   cond(cond_) {}
-
-    template <typename DoT>
-    lambda_functor<while_composite<
-        typename as_lambda_functor<CondT>::type,
-        typename as_lambda_functor<DoT>::type> >
-    operator[](DoT const& do_) const
-    {
-        typedef while_composite<
-            typename as_lambda_functor<CondT>::type,
-            typename as_lambda_functor<DoT>::type>
-        result;
-
-        return result(
-            to_lambda_functor(cond),
-            to_lambda_functor(do_));
-    }
-
-    CondT cond;
-};
-
-//////////////////////////////////
-template <typename CondT>
-inline while_gen<CondT>
-while_(CondT const& cond)
-{
-    return while_gen<CondT>(cond);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  do_composite
-//
-//      This composite has the form:
-//
-//          do_
-//          [
-//              statement
-//          ]
-//          .while_(condition)
-//
-//      While the condition (an lambda_functor) evaluates to true, statement
-//      (another lambda_functor) is executed. The statement is executed at least
-//      once. The result type of this is void. Note the trailing
-//      underscore after do_ and the leading dot and the trailing
-//      underscore before and after .while_.
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename DoT, typename CondT>
-struct do_composite {
-
-    typedef do_composite<DoT, CondT> self_t;
-
-    template <class SigArgs>
-    struct sig { typedef void type; };
-
-    do_composite(DoT const& do__, CondT const& cond_)
-    :   do_(do__), cond(cond_) {}
-
-    template <class Ret, CALL_TEMPLATE_ARGS>
-    Ret call(CALL_FORMAL_ARGS) const
-    {
-        do
-            do_.internal_call(CALL_ACTUAL_ARGS);
-        while (cond.internal_call(CALL_ACTUAL_ARGS));
-    }
-
-    DoT do_;
-    CondT cond;
-};
-
-////////////////////////////////////
-template <typename DoT>
-struct do_gen2 {
-
-    do_gen2(DoT const& do__)
-    :   do_(do__) {}
-
-    template <typename CondT>
-    lambda_functor<do_composite<
-        typename as_lambda_functor<DoT>::type,
-        typename as_lambda_functor<CondT>::type> >
-    while_(CondT const& cond) const
-    {
-        typedef do_composite<
-            typename as_lambda_functor<DoT>::type,
-            typename as_lambda_functor<CondT>::type>
-        result;
-
-        return result(
-            to_lambda_functor(do_),
-            to_lambda_functor(cond));
-    }
-
-    DoT do_;
-};
-
-////////////////////////////////////
-struct do_gen {
-
-    template <typename DoT>
-    do_gen2<DoT>
-    operator[](DoT const& do_) const
-    {
-        return do_gen2<DoT>(do_);
-    }
-};
-
-do_gen const do_ = do_gen();
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  for_composite
-//
-//      This statement has the form:
-//
-//          for_(init, condition, step)
-//          [
-//              statement
-//          ]
-//
-//      Where init, condition, step and statement are all lambda_functors. init
-//      is executed once before entering the for-loop. The for-loop
-//      exits once condition evaluates to false. At each loop iteration,
-//      step and statement is called. The result of this statement is
-//      void. Note the trailing underscore after for_.
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename InitT, typename CondT, typename StepT, typename DoT>
-struct for_composite {
-
-    template <class SigArgs>
-    struct sig { typedef void type; };
-
-    for_composite(
-        InitT const& init_,
-        CondT const& cond_,
-        StepT const& step_,
-        DoT const& do__)
-    :   init(init_), cond(cond_), step(step_), do_(do__) {}
-
-    template <class Ret, CALL_TEMPLATE_ARGS>
-    Ret
-    call(CALL_FORMAL_ARGS) const
-    {
-        for (init.internal_call(CALL_ACTUAL_ARGS); cond.internal_call(CALL_ACTUAL_ARGS); step.internal_call(CALL_ACTUAL_ARGS))
-            do_.internal_call(CALL_ACTUAL_ARGS);
-    }
-
-    InitT init; CondT cond; StepT step; DoT do_; //  lambda_functors
-};
-
-//////////////////////////////////
-template <typename InitT, typename CondT, typename StepT>
-struct for_gen {
-
-    for_gen(
-        InitT const& init_,
-        CondT const& cond_,
-        StepT const& step_)
-    :   init(init_), cond(cond_), step(step_) {}
-
-    template <typename DoT>
-    lambda_functor<for_composite<
-        typename as_lambda_functor<InitT>::type,
-        typename as_lambda_functor<CondT>::type,
-        typename as_lambda_functor<StepT>::type,
-        typename as_lambda_functor<DoT>::type> >
-    operator[](DoT const& do_) const
-    {
-        typedef for_composite<
-            typename as_lambda_functor<InitT>::type,
-            typename as_lambda_functor<CondT>::type,
-            typename as_lambda_functor<StepT>::type,
-            typename as_lambda_functor<DoT>::type>
-        result;
-
-        return result(
-            to_lambda_functor(init),
-            to_lambda_functor(cond),
-            to_lambda_functor(step),
-            to_lambda_functor(do_));
-    }
-
-    InitT init; CondT cond; StepT step;
-};
-
-//////////////////////////////////
-template <typename InitT, typename CondT, typename StepT>
-inline for_gen<InitT, CondT, StepT>
-for_(InitT const& init, CondT const& cond, StepT const& step)
-{
-    return for_gen<InitT, CondT, StepT>(init, cond, step);
-}
-
-} // lambda
-} // boost
-
-#endif // BOOST_LAMBDA_LOOPS_HPP
diff --git a/contrib/restricted/boost/boost/lambda/numeric.hpp b/contrib/restricted/boost/boost/lambda/numeric.hpp
deleted file mode 100644
index 40a95c74bb..0000000000
--- a/contrib/restricted/boost/boost/lambda/numeric.hpp
+++ /dev/null
@@ -1,119 +0,0 @@
-// -- numeric.hpp -- Boost Lambda Library -----------------------------------
-// Copyright (C) 2002 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2002 Gary Powell (gwpowell@hotmail.com)
-//
-// Distributed under 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)
-//
-// For more information, see http://www.boost.org
-
-#ifndef BOOST_LAMBDA_NUMERIC_HPP
-#define BOOST_LAMBDA_NUMERIC_HPP
-
-#include "boost/lambda/core.hpp"
-
-#include <numeric>
-
-namespace boost {
-  namespace lambda {
-
-namespace ll {
-
-// accumulate ---------------------------------
-
-struct accumulate {
-  
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<3, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class B, class C>
-  C
-  operator()(A a, B b, C c) const
-  { return ::std::accumulate(a, b, c); }
-
-  template <class A, class B, class C, class D>
-  C
-  operator()(A a, B b, C c, D d) const
-  { return ::std::accumulate(a, b, c, d); }
-};
-
-// inner_product ---------------------------------
-
-struct inner_product {
-  
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<4, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class B, class C, class D>
-  D
-  operator()(A a, B b, C c, D d) const
-  { return ::std::inner_product(a, b, c, d); }
-
-  template <class A, class B, class C, class D, class E, class F>
-  D
-  operator()(A a, B b, C c, D d, E e, F f) const
-  { return ::std::inner_product(a, b, c, d, e, f); }
-};
-
-
-// partial_sum ---------------------------------
-
-struct partial_sum {
-  
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<3, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class B, class C>
-  C
-  operator()(A a, B b, C c) const
-  { return ::std::partial_sum(a, b, c); }
-
-  template <class A, class B, class C, class D>
-  C
-  operator()(A a, B b, C c, D d) const
-  { return ::std::partial_sum(a, b, c, d); }
-};
-
-// adjacent_difference ---------------------------------
-
-struct adjacent_difference {
-  
-  template <class Args>
-  struct sig { 
-    typedef typename boost::remove_const<
-        typename boost::tuples::element<3, Args>::type 
-     >::type type; 
-  };
-
-  template <class A, class B, class C>
-  C
-  operator()(A a, B b, C c) const
-  { return ::std::adjacent_difference(a, b, c); }
-
-  template <class A, class B, class C, class D>
-  C
-  operator()(A a, B b, C c, D d) const
-  { return ::std::adjacent_difference(a, b, c, d); }
-};
-
-} // end of ll namespace
-
-} // end of lambda namespace
-} // end of boost namespace
-
-
-
-#endif
diff --git a/contrib/restricted/boost/boost/lambda/switch.hpp b/contrib/restricted/boost/boost/lambda/switch.hpp
deleted file mode 100644
index 05d02e98c3..0000000000
--- a/contrib/restricted/boost/boost/lambda/switch.hpp
+++ /dev/null
@@ -1,508 +0,0 @@
-// Boost Lambda Library -- switch.hpp -----------------------------------
-//
-// Copyright (C) 2000 Gary Powell (powellg@amazon.com)
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//
-// Distributed under 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)
-//
-// For more information, see www.boost.org
-
-// --------------------------------------------------------------------------
-
-#if !defined(BOOST_LAMBDA_SWITCH_HPP)
-#define BOOST_LAMBDA_SWITCH_HPP
-
-#include "boost/lambda/core.hpp"
-#include "boost/lambda/detail/control_constructs_common.hpp"
-
-#include "boost/preprocessor/enum_shifted_params.hpp"
-#include "boost/preprocessor/repeat_2nd.hpp"
-#include "boost/preprocessor/tuple.hpp"
-
-namespace boost { 
-namespace lambda {
-
-// Switch actions
-template <int N, class Switch1 = null_type, class Switch2 = null_type, 
-          class Switch3 = null_type, class Switch4 = null_type,
-          class Switch5 = null_type, class Switch6 = null_type, 
-          class Switch7 = null_type, class Switch8 = null_type, 
-          class Switch9 = null_type>
-struct switch_action {};
-
-
-namespace detail {
-
-  // templates to represent special lambda functors for the cases in 
-  // switch statements
-  
-template <int Value> struct case_label {};
-struct default_label {};
-
-template<class Type> struct switch_case_tag {};
-
-  // a normal case is represented as:
-  // tagged_lambda_functor<switch_case_tag<case_label<N> > >, LambdaFunctor>
-  
-  // the default case as:
-  // tagged_lambda_functor<switch_case_tag<default_label> >, LambdaFunctor>
-
-
-} // end detail
-
-
-/// create switch_case_tag tagged_lambda_functors
-template <int CaseValue, class Arg>
-inline const 
-tagged_lambda_functor<
-  detail::switch_case_tag<detail::case_label<CaseValue> >, 
-  lambda_functor<Arg> 
-> 
-case_statement(const lambda_functor<Arg>& a) { 
-  return 
-    tagged_lambda_functor<
-      detail::switch_case_tag<detail::case_label<CaseValue> >, 
-      lambda_functor<Arg> 
-    >(a); 
-}
-
-// No case body case.
-template <int CaseValue>
-inline const 
-tagged_lambda_functor<
-  detail::switch_case_tag<detail::case_label<CaseValue> >,
-  lambda_functor< 
-    lambda_functor_base< 
-      do_nothing_action, 
-      null_type
-    > 
-  > 
-> 
-case_statement() { 
-return 
-  tagged_lambda_functor<
-    detail::switch_case_tag<detail::case_label<CaseValue> >,
-    lambda_functor< 
-      lambda_functor_base< 
-        do_nothing_action, 
-        null_type
-      > 
-    > 
-  > () ;
-}
-
-// default label
-template <class Arg>
-inline const 
-tagged_lambda_functor<
-  detail::switch_case_tag<detail::default_label>, 
-  lambda_functor<Arg> 
-> 
-default_statement(const lambda_functor<Arg>& a) { 
-  return 
-    tagged_lambda_functor<
-      detail::switch_case_tag<detail::default_label>, 
-      lambda_functor<Arg> 
-    >(a); 
-}
-
-// default lable, no case body case.
-inline const 
-tagged_lambda_functor<
-  detail::switch_case_tag<detail::default_label>,
-  lambda_functor< 
-    lambda_functor_base< 
-      do_nothing_action, 
-      null_type
-    > 
-  > 
-> 
-default_statement() { 
-return 
-      lambda_functor_base< 
-        do_nothing_action, 
-        null_type 
-      > () ;
-}
-
-
-// Specializations for lambda_functor_base of case_statement -----------------
-
-// 0 case type:
-// useless (just the condition part) but provided for completeness.
-template<class Args>
-class 
-lambda_functor_base<
-  switch_action<1>, 
-  Args
-> 
-{
-public:
-  Args args;
-  template <class SigArgs> struct sig { typedef void type; };
-public:
-  explicit lambda_functor_base(const Args& a) : args(a) {}
-
-  template<class RET, CALL_TEMPLATE_ARGS>
-  RET call(CALL_FORMAL_ARGS) const {
-    detail::select(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS);  
-  }
-};
-
-// 1 case type:
-// template<class Args, int Case1>
-// class 
-// lambda_functor_base<
-//   action<
-//     2, 
-//     return_void_action<switch_action<detail::case_label<Case1> > > 
-//   >, 
-//   Args
-// > 
-// {
-//   Args args;
-// public:
-//   explicit lambda_functor_base(const Args& a) : args(a) {}
-
-//   template<class RET, class A, class B, class C>
-//   RET call(A& a, B& b, C& c) const {
-//     switch( detail::select(::boost::tuples::get<0>(args), a, b, c) )  
-//     {
-//       case Case1:                
-//         detail::select(::boost::tuples::get<1>(args), a, b, c);
-//         break;
-//     }
-//   }
-// };
-
-// switch with default being the sole label - doesn't make much sense but
-// it is there for completeness
-// template<class Args>
-// class
-// lambda_functor_base<
-//   action<
-//     2,
-//     return_void_action<switch_action<detail::default_label> >
-//   >,
-//   Args
-// >
-// {
-//   Args args;
-// public:
-//   explicit lambda_functor_base(const Args& a) : args(a) {}
-// 
-//   template<class RET, class A, class B, class C>
-//   RET call(A& a, B& b, C& c) const {
-//     switch( detail::select(::boost::tuples::get<0>(args), a, b, c) )
-//     {
-//       default:
-//         detail::select(::boost::tuples::get<1>(args), a, b, c);
-//         break;
-//     }
-//   }
-// };
-
-
-
-// // 2 case type:
-// The different specializations are generated with Vesa Karvonen's 
-// preprocessor library.
-
-// This is just a comment to show what the generated classes look like
-
-// template<class Args, int Case1, int Case2>
-// class 
-// lambda_functor_base<
-//   action<3, 
-//     return_void_action< 
-//       switch_action< 
-//         detail::case_label<Case1>,
-//         detail::case_label<Case2>
-//       > 
-//     > 
-//   >, 
-//   Args
-// > 
-// {
-//   Args args;
-// public:
-//   explicit lambda_functor_base(const Args& a) : args(a) {}
-
-//   template<class RET, class A, class B, class C>
-//   RET call(A& a, B& b, C& c) const {
-//     switch( detail::select(::boost::tuples::get<0>(args), a, b, c) )  
-//     {
-//       case Case1:                
-//         detail::select(::boost::tuples::get<1>(args), a, b, c);
-//         break;
-//       case Case2:                
-//         detail::select(::boost::tuples::get<2>(args), a, b, c);
-//         break;
-//     }
-//   }
-// };
-
-// template<class Args, int Case1>
-// class 
-// lambda_functor_base<
-//   action<3, 
-//     return_void_action< 
-//       switch_action< 
-//         detail::case_label<Case1>,
-//         detail::default_label 
-//       > 
-//     > 
-//   >, 
-//   Args
-// > 
-// {
-//   Args args;
-// public:
-//   explicit lambda_functor_base(const Args& a) : args(a) {}
-
-//   template<class RET, class A, class B, class C>
-//   RET call(A& a, B& b, C& c) const {
-//     switch( detail::select(::boost::tuples::get<0>(args), a, b, c) )  
-//     {
-//       case Case1:                
-//         detail::select(::boost::tuples::get<1>(args), a, b, c);
-//         break;
-//       default:                
-//         detail::select(::boost::tuples::get<2>(args), a, b, c);
-//         break;
-//     }
-//   }
-// };
-// -------------------------
-
-// Some helper preprocessor macros ---------------------------------
-
-// BOOST_LAMBDA_A_I_LIST(N, X) is a list of form X0, X1, ..., XN
-// BOOST_LAMBDA_A_I_B_LIST(N, X, Y) is a list of form X0 Y, X1 Y, ..., XN Y
-
-#define BOOST_LAMBDA_A_I(z, i, A) \
-BOOST_PP_COMMA_IF(i) BOOST_PP_CAT(A,i)
-
-#define BOOST_LAMBDA_A_I_B(z, i, T) \
-BOOST_PP_COMMA_IF(i) BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2,0,T),i) BOOST_PP_TUPLE_ELEM(2,1,T)
-
-#define BOOST_LAMBDA_A_I_LIST(i, A) \
-BOOST_PP_REPEAT(i,BOOST_LAMBDA_A_I, A) 
-
-#define BOOST_LAMBDA_A_I_B_LIST(i, A, B) \
-BOOST_PP_REPEAT(i,BOOST_LAMBDA_A_I_B, (A,B)) 
-
-
-// Switch related macros -------------------------------------------
-#define BOOST_LAMBDA_SWITCH_CASE_BLOCK(z, N, A) \
-  case Case##N: \
-  detail::select(::boost::tuples::get<BOOST_PP_INC(N)>(args), CALL_ACTUAL_ARGS); \
-  break;
-
-#define BOOST_LAMBDA_SWITCH_CASE_BLOCK_LIST(N) \
-BOOST_PP_REPEAT(N, BOOST_LAMBDA_SWITCH_CASE_BLOCK, FOO)
-// 2 case type:
-
-#define BOOST_LAMBDA_SWITCH_NO_DEFAULT_CASE(N)                                \
-template<class Args, BOOST_LAMBDA_A_I_LIST(N, int Case)>                      \
-class                                                                         \
-lambda_functor_base<                                                          \
-      switch_action<BOOST_PP_INC(N),                                          \
-        BOOST_LAMBDA_A_I_B_LIST(N, detail::case_label<Case,>)                 \
-      >,                                                                      \
-  Args                                                                        \
->                                                                             \
-{                                                                             \
-public:                                                                       \
-  Args args;                                                                  \
-  template <class SigArgs> struct sig { typedef void type; };                 \
-public:                                                                       \
-  explicit lambda_functor_base(const Args& a) : args(a) {}                    \
-                                                                              \
-  template<class RET, CALL_TEMPLATE_ARGS>                                     \
-  RET call(CALL_FORMAL_ARGS) const {                                          \
-    switch( detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) ) \
-    {                                                                         \
-      BOOST_LAMBDA_SWITCH_CASE_BLOCK_LIST(N)                                  \
-    }                                                                         \
-  }                                                                           \
-};
-
-        
-
-#define BOOST_LAMBDA_SWITCH_WITH_DEFAULT_CASE(N)                              \
-template<                                                                     \
-  class Args BOOST_PP_COMMA_IF(BOOST_PP_DEC(N))                               \
-  BOOST_LAMBDA_A_I_LIST(BOOST_PP_DEC(N), int Case)                            \
->                                                                             \
-class                                                                         \
-lambda_functor_base<                                                          \
-      switch_action<BOOST_PP_INC(N),                                          \
-        BOOST_LAMBDA_A_I_B_LIST(BOOST_PP_DEC(N),                              \
-                                detail::case_label<Case, >)                   \
-        BOOST_PP_COMMA_IF(BOOST_PP_DEC(N))                                    \
-        detail::default_label                                                 \
-      >,                                                                      \
-  Args                                                                        \
->                                                                             \
-{                                                                             \
-public:                                                                       \
-  Args args;                                                                  \
-  template <class SigArgs> struct sig { typedef void type; };                 \
-public:                                                                       \
-  explicit lambda_functor_base(const Args& a) : args(a) {}                    \
-                                                                              \
-  template<class RET, CALL_TEMPLATE_ARGS>                                     \
-  RET call(CALL_FORMAL_ARGS) const {                                          \
-    switch( detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) ) \
-    {                                                                         \
-        BOOST_LAMBDA_SWITCH_CASE_BLOCK_LIST(BOOST_PP_DEC(N))                  \
-      default:                                                                \
-        detail::select(::boost::tuples::get<N>(args), CALL_ACTUAL_ARGS);      \
-        break;                                                                \
-    }                                                                         \
-  }                                                                           \
-};
-
-
-
-
-
-
-// switch_statement bind functions -------------------------------------
-
-// The zero argument case, for completeness sake
-inline const 
-lambda_functor< 
-  lambda_functor_base< 
-    do_nothing_action, 
-    null_type
-  > 
->
-switch_statement() { 
-  return 
-      lambda_functor_base< 
-        do_nothing_action, 
-        null_type
-      > 
-  ();
-}
-
-// 1 argument case, this is useless as well, just the condition part
-template <class TestArg>
-inline const 
-lambda_functor< 
-  lambda_functor_base< 
-    switch_action<1>, 
-    tuple<lambda_functor<TestArg> >
-  > 
->
-switch_statement(const lambda_functor<TestArg>& a1) { 
-  return 
-      lambda_functor_base< 
-         switch_action<1>, 
-         tuple< lambda_functor<TestArg> > 
-      > 
-    ( tuple<lambda_functor<TestArg> >(a1));
-}
-
-
-#define HELPER(z, N, FOO)                                      \
-BOOST_PP_COMMA_IF(N)                                           \
-BOOST_PP_CAT(                                                  \
-  const tagged_lambda_functor<detail::switch_case_tag<TagData, \
-  N>)                                                          \
-BOOST_PP_COMMA() Arg##N>& a##N
-
-#define HELPER_LIST(N) BOOST_PP_REPEAT(N, HELPER, FOO)
-
-
-#define BOOST_LAMBDA_SWITCH_STATEMENT(N)                              \
-template <class TestArg,                                              \
-          BOOST_LAMBDA_A_I_LIST(N, class TagData),                    \
-          BOOST_LAMBDA_A_I_LIST(N, class Arg)>                        \
-inline const                                                          \
-lambda_functor<                                                       \
-  lambda_functor_base<                                                \
-        switch_action<BOOST_PP_INC(N),                                \
-          BOOST_LAMBDA_A_I_LIST(N, TagData)                           \
-        >,                                                            \
-    tuple<lambda_functor<TestArg>, BOOST_LAMBDA_A_I_LIST(N, Arg)>     \
-  >                                                                   \
->                                                                     \
-switch_statement(                                                     \
-  const lambda_functor<TestArg>& ta,                                  \
-  HELPER_LIST(N)                                                      \
-)                                                                     \
-{                                                                     \
-  return                                                              \
-      lambda_functor_base<                                            \
-            switch_action<BOOST_PP_INC(N),                            \
-              BOOST_LAMBDA_A_I_LIST(N, TagData)                       \
-            >,                                                        \
-        tuple<lambda_functor<TestArg>, BOOST_LAMBDA_A_I_LIST(N, Arg)> \
-      >                                                               \
-    ( tuple<lambda_functor<TestArg>, BOOST_LAMBDA_A_I_LIST(N, Arg)>   \
-        (ta, BOOST_LAMBDA_A_I_LIST(N, a) ));                          \
-}
-
-
-
-
-// Here's the actual generation
-
-#define BOOST_LAMBDA_SWITCH(N)           \
-BOOST_LAMBDA_SWITCH_NO_DEFAULT_CASE(N)   \
-BOOST_LAMBDA_SWITCH_WITH_DEFAULT_CASE(N)        
-
-// Use this to avoid case 0, these macros work only from case 1 upwards
-#define BOOST_LAMBDA_SWITCH_HELPER(z, N, A) \
-BOOST_LAMBDA_SWITCH( BOOST_PP_INC(N) )
-
-// Use this to avoid cases 0 and 1, these macros work only from case 2 upwards
-#define BOOST_LAMBDA_SWITCH_STATEMENT_HELPER(z, N, A) \
-BOOST_LAMBDA_SWITCH_STATEMENT(BOOST_PP_INC(N))
-
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4065)
-#endif
-
-  // up to 9 cases supported (counting default:)
-BOOST_PP_REPEAT_2ND(9,BOOST_LAMBDA_SWITCH_HELPER,FOO)
-BOOST_PP_REPEAT_2ND(9,BOOST_LAMBDA_SWITCH_STATEMENT_HELPER,FOO)
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-} // namespace lambda 
-} // namespace boost
-
-
-#undef HELPER
-#undef HELPER_LIST
-
-#undef BOOST_LAMBDA_SWITCH_HELPER
-#undef BOOST_LAMBDA_SWITCH
-#undef BOOST_LAMBDA_SWITCH_NO_DEFAULT_CASE
-#undef BOOST_LAMBDA_SWITCH_WITH_DEFAULT_CASE
-
-#undef BOOST_LAMBDA_SWITCH_CASE_BLOCK
-#undef BOOST_LAMBDA_SWITCH_CASE_BLOCK_LIST
-
-#undef BOOST_LAMBDA_SWITCH_STATEMENT
-#undef BOOST_LAMBDA_SWITCH_STATEMENT_HELPER
-
-
-
-#endif
-
-
-
-
-
-
-
diff --git a/contrib/restricted/boost/lambda/CMakeLists.txt b/contrib/restricted/boost/lambda/CMakeLists.txt
new file mode 100644
index 0000000000..ecd0f17c6f
--- /dev/null
+++ b/contrib/restricted/boost/lambda/CMakeLists.txt
@@ -0,0 +1,27 @@
+
+# This file was gererated by the build system used internally in the Yandex monorepo.
+# Only simple modifications are allowed (adding source-files to targets, adding simple properties
+# like target_include_directories). These modifications will be ported to original
+# ya.make files by maintainers. Any complex modifications which can't be ported back to the
+# original buildsystem will not be accepted.
+
+
+
+add_library(restricted-boost-lambda INTERFACE)
+target_include_directories(restricted-boost-lambda INTERFACE
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/boost/lambda/include
+)
+target_link_libraries(restricted-boost-lambda INTERFACE
+  contrib-libs-cxxsupp
+  yutil
+  restricted-boost-bind
+  restricted-boost-config
+  restricted-boost-core
+  restricted-boost-detail
+  restricted-boost-iterator
+  restricted-boost-mpl
+  restricted-boost-preprocessor
+  restricted-boost-tuple
+  restricted-boost-type_traits
+  restricted-boost-utility
+)