text: 
  // Copyright Aleksey Gurtovoy 2001-2004
  //
  // 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)
  //
  
  // Preprocessed version of "boost/mpl/aux_/full_lambda.hpp" header
  // -- DO NOT modify by hand!
  
  namespace boost { namespace mpl {
  
  namespace aux {
  
  template<
        bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false
      , bool C5 = false
      >
  struct lambda_or
      : true_
  {
  };
  
  template<>
  struct lambda_or< false,false,false,false,false >
      : false_
  {
  };
  
  } // namespace aux
  
  template<
        typename T
      , typename Tag
  
      >
  struct lambda
  {
      typedef false_ is_le;
      typedef T result_;
      typedef T type;
  };
  
  template<
        typename T
      >
  struct is_lambda_expression
      : lambda<T>::is_le
  {
  };
  
  template< int N, typename Tag >
  struct lambda< arg<N>, Tag >
  {
      typedef true_ is_le;
      typedef mpl::arg<N> result_; // qualified for the sake of MIPSpro 7.41
      typedef mpl::protect<result_> type;
  };
  
  template<
        typename F
      , typename Tag
      >
  struct lambda<
            bind0<F>
          , Tag
  
          >
  {
      typedef false_ is_le;
      typedef bind0<
            F
          > result_;
  
      typedef result_ type;
  };
  
  namespace aux {
  
  template<
        typename IsLE, typename Tag
      , template< typename P1 > class F
      , typename L1
      >
  struct le_result1
  {
      typedef F<
            typename L1::type
          > result_;
  
      typedef result_ type;
  };
  
  template<
        typename Tag
      , template< typename P1 > class F
      , typename L1
      >
  struct le_result1< true_,Tag,F,L1 >
  {
      typedef bind1<
            quote1< F,Tag >
          , typename L1::result_
          > result_;
  
      typedef mpl::protect<result_> type;
  };
  
  } // namespace aux
  
  template<
        template< typename P1 > class F
      , typename T1
      , typename Tag
      >
  struct lambda<
            F<T1>
          , Tag
  
          >
  {
      typedef lambda< T1,Tag > l1;
      typedef typename l1::is_le is_le1;
      typedef typename aux::lambda_or<
            is_le1::value
          >::type is_le;
  
      typedef aux::le_result1<
            is_le, Tag, F, l1
          > le_result_;
  
      typedef typename le_result_::result_ result_;
      typedef typename le_result_::type type;
  };
  
  template<
        typename F, typename T1
      , typename Tag
      >
  struct lambda<
            bind1< F,T1 >
          , Tag
  
          >
  {
      typedef false_ is_le;
      typedef bind1<
            F
          , T1
          > result_;
  
      typedef result_ type;
  };
  
  namespace aux {
  
  template<
        typename IsLE, typename Tag
      , template< typename P1, typename P2 > class F
      , typename L1, typename L2
      >
  struct le_result2
  {
      typedef F<
            typename L1::type, typename L2::type
          > result_;
  
      typedef result_ type;
  };
  
  template<
        typename Tag
      , template< typename P1, typename P2 > class F
      , typename L1, typename L2
      >
  struct le_result2< true_,Tag,F,L1,L2 >
  {
      typedef bind2<
            quote2< F,Tag >
          , typename L1::result_, typename L2::result_
          > result_;
  
      typedef mpl::protect<result_> type;
  };
  
  } // namespace aux
  
  template<
        template< typename P1, typename P2 > class F
      , typename T1, typename T2
      , typename Tag
      >
  struct lambda<
            F< T1,T2 >
          , Tag
  
          >
  {
      typedef lambda< T1,Tag > l1;
      typedef lambda< T2,Tag > l2;
  
      typedef typename l1::is_le is_le1;
      typedef typename l2::is_le is_le2;
  
  
      typedef typename aux::lambda_or<
            is_le1::value, is_le2::value
          >::type is_le;
  
      typedef aux::le_result2<
            is_le, Tag, F, l1, l2
          > le_result_;
  
      typedef typename le_result_::result_ result_;
      typedef typename le_result_::type type;
  };
  
  template<
        typename F, typename T1, typename T2
      , typename Tag
      >
  struct lambda<
            bind2< F,T1,T2 >
          , Tag
  
          >
  {
      typedef false_ is_le;
      typedef bind2<
            F
          , T1, T2
          > result_;
  
      typedef result_ type;
  };
  
  namespace aux {
  
  template<
        typename IsLE, typename Tag
      , template< typename P1, typename P2, typename P3 > class F
      , typename L1, typename L2, typename L3
      >
  struct le_result3
  {
      typedef F<
            typename L1::type, typename L2::type, typename L3::type
          > result_;
  
      typedef result_ type;
  };
  
  template<
        typename Tag
      , template< typename P1, typename P2, typename P3 > class F
      , typename L1, typename L2, typename L3
      >
  struct le_result3< true_,Tag,F,L1,L2,L3 >
  {
      typedef bind3<
            quote3< F,Tag >
          , typename L1::result_, typename L2::result_, typename L3::result_
          > result_;
  
      typedef mpl::protect<result_> type;
  };
  
  } // namespace aux
  
  template<
        template< typename P1, typename P2, typename P3 > class F
      , typename T1, typename T2, typename T3
      , typename Tag
      >
  struct lambda<
            F< T1,T2,T3 >
          , Tag
  
          >
  {
      typedef lambda< T1,Tag > l1;
      typedef lambda< T2,Tag > l2;
      typedef lambda< T3,Tag > l3;
  
      typedef typename l1::is_le is_le1;
      typedef typename l2::is_le is_le2;
      typedef typename l3::is_le is_le3;
  
  
      typedef typename aux::lambda_or<
            is_le1::value, is_le2::value, is_le3::value
          >::type is_le;
  
      typedef aux::le_result3<
            is_le, Tag, F, l1, l2, l3
          > le_result_;
  
      typedef typename le_result_::result_ result_;
      typedef typename le_result_::type type;
  };
  
  template<
        typename F, typename T1, typename T2, typename T3
      , typename Tag
      >
  struct lambda<
            bind3< F,T1,T2,T3 >
          , Tag
  
          >
  {
      typedef false_ is_le;
      typedef bind3<
            F
          , T1, T2, T3
          > result_;
  
      typedef result_ type;
  };
  
  namespace aux {
  
  template<
        typename IsLE, typename Tag
      , template< typename P1, typename P2, typename P3, typename P4 > class F
      , typename L1, typename L2, typename L3, typename L4
      >
  struct le_result4
  {
      typedef F<
            typename L1::type, typename L2::type, typename L3::type
          , typename L4::type
          > result_;
  
      typedef result_ type;
  };
  
  template<
        typename Tag
      , template< typename P1, typename P2, typename P3, typename P4 > class F
      , typename L1, typename L2, typename L3, typename L4
      >
  struct le_result4< true_,Tag,F,L1,L2,L3,L4 >
  {
      typedef bind4<
            quote4< F,Tag >
          , typename L1::result_, typename L2::result_, typename L3::result_
          , typename L4::result_
          > result_;
  
      typedef mpl::protect<result_> type;
  };
  
  } // namespace aux
  
  template<
        template< typename P1, typename P2, typename P3, typename P4 > class F
      , typename T1, typename T2, typename T3, typename T4
      , typename Tag
      >
  struct lambda<
            F< T1,T2,T3,T4 >
          , Tag
  
          >
  {
      typedef lambda< T1,Tag > l1;
      typedef lambda< T2,Tag > l2;
      typedef lambda< T3,Tag > l3;
      typedef lambda< T4,Tag > l4;
  
      typedef typename l1::is_le is_le1;
      typedef typename l2::is_le is_le2;
      typedef typename l3::is_le is_le3;
      typedef typename l4::is_le is_le4;
  
  
      typedef typename aux::lambda_or<
            is_le1::value, is_le2::value, is_le3::value, is_le4::value
          >::type is_le;
  
      typedef aux::le_result4<
            is_le, Tag, F, l1, l2, l3, l4
          > le_result_;
  
      typedef typename le_result_::result_ result_;
      typedef typename le_result_::type type;
  };
  
  template<
        typename F, typename T1, typename T2, typename T3, typename T4
      , typename Tag
      >
  struct lambda<
            bind4< F,T1,T2,T3,T4 >
          , Tag
  
          >
  {
      typedef false_ is_le;
      typedef bind4<
            F
          , T1, T2, T3, T4
          > result_;
  
      typedef result_ type;
  };
  
  namespace aux {
  
  template<
        typename IsLE, typename Tag
      , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F
      , typename L1, typename L2, typename L3, typename L4, typename L5
      >
  struct le_result5
  {
      typedef F<
            typename L1::type, typename L2::type, typename L3::type
          , typename L4::type, typename L5::type
          > result_;
  
      typedef result_ type;
  };
  
  template<
        typename Tag
      , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F
      , typename L1, typename L2, typename L3, typename L4, typename L5
      >
  struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 >
  {
      typedef bind5<
            quote5< F,Tag >
          , typename L1::result_, typename L2::result_, typename L3::result_
          , typename L4::result_, typename L5::result_
          > result_;
  
      typedef mpl::protect<result_> type;
  };
  
  } // namespace aux
  
  template<
        template<
            typename P1, typename P2, typename P3, typename P4
          , typename P5
          >
        class F
      , typename T1, typename T2, typename T3, typename T4, typename T5
      , typename Tag
      >
  struct lambda<
            F< T1,T2,T3,T4,T5 >
          , Tag
  
          >
  {
      typedef lambda< T1,Tag > l1;
      typedef lambda< T2,Tag > l2;
      typedef lambda< T3,Tag > l3;
      typedef lambda< T4,Tag > l4;
      typedef lambda< T5,Tag > l5;
  
      typedef typename l1::is_le is_le1;
      typedef typename l2::is_le is_le2;
      typedef typename l3::is_le is_le3;
      typedef typename l4::is_le is_le4;
      typedef typename l5::is_le is_le5;
  
  
      typedef typename aux::lambda_or<
            is_le1::value, is_le2::value, is_le3::value, is_le4::value
          , is_le5::value
          >::type is_le;
  
      typedef aux::le_result5<
            is_le, Tag, F, l1, l2, l3, l4, l5
          > le_result_;
  
      typedef typename le_result_::result_ result_;
      typedef typename le_result_::type type;
  };
  
  template<
        typename F, typename T1, typename T2, typename T3, typename T4
      , typename T5
      , typename Tag
      >
  struct lambda<
            bind5< F,T1,T2,T3,T4,T5 >
          , Tag
  
          >
  {
      typedef false_ is_le;
      typedef bind5<
            F
          , T1, T2, T3, T4, T5
          > result_;
  
      typedef result_ type;
  };
  
  /// special case for 'protect'
  template< typename T, typename Tag >
  struct lambda< mpl::protect<T>, Tag >
  {
      typedef false_ is_le;
      typedef mpl::protect<T> result_;
      typedef result_ type;
  };
  
  /// specializations for the main 'bind' form
  
  template<
        typename F, typename T1, typename T2, typename T3, typename T4
      , typename T5
      , typename Tag
      >
  struct lambda<
            bind< F,T1,T2,T3,T4,T5 >
          , Tag
  
          >
  {
      typedef false_ is_le;
      typedef bind< F,T1,T2,T3,T4,T5 > result_;
      typedef result_ type;
  };
  
  /// workaround for MWCW 8.3+/EDG < 303, leads to ambiguity on Digital Mars
  
  template<
        typename F, typename Tag1, typename Tag2
      >
  struct lambda<
            lambda< F,Tag1 >
          , Tag2
          >
  {
      typedef lambda< F,Tag2 > l1;
      typedef lambda< Tag1,Tag2 > l2;
      typedef typename l1::is_le is_le;
      typedef aux::le_result2<is_le, Tag2, mpl::lambda, l1, l2> le_result_;
      typedef typename le_result_::result_ result_;
      typedef typename le_result_::type type;
  };
  
  BOOST_MPL_AUX_NA_SPEC(2, lambda)
  
  }}
  