// -- algorithm.hpp -- Boost Lambda Library -----------------------------------

 // Copyright (C) 2002 Jaakko Järvi (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